Hot answers tagged geometric-transform
18
The idea is quite simple:
Since any great circle can be parametrized as $\cos(\theta)u + \sin(\theta)v$ where $u$ and $v$ are two orthonormal vectors. One can start with $u=\{1,0,0\}, v=\{0,1,0\}$ and use RotationTransform to get out of the xy plane, then use RotationTransform again to spin around the z-axis to get all great circles with desired inclination.
...
16
This is just a quick sketching out of an answer (rescales galore!)
textOnCurve[text_, f_, n_, p_: 0.01] :=
Text[Rotate[text, ArcTan @@ (f[Rescale[n + p, {0, 1}, {p, 1 - p}]] -
f[Rescale[n - p, {0, 1}, {p, 1 - p}]])], f[n]]
textCurve[string_, f_, stylef_: (# &), range_: {0, 1}] :=
With[{chars = ...
13
Here's a simple method that seems to work. Call the grid above img. Find the best/strongest line in the image:
lines = ImageLines[img, MaxFeatures -> 1]
We'll need the slope of this line - here's a function to do that
slope[s_, e_] := ArcTan@@(e - s);
(shorter version thanks to nikie). This can be applied as
slopeLine = First[slope @@@ lines]
For ...
13
Here is a static solution to the problem. It shows a mesh on the sphere that represents the normal lat-long coordinate system.
A function representing the equator.
equator[θ_] := {Cos[θ], Sin[θ], 0}
A function and a plot representing the inclined circle. Note that the inclination is accomplished by a rotation of the equator about the x-axis.
...
11
Here's another way...Text[] has a direction argument, so ArcTan is not necessary.
txt1 = "Now we can follow" // Characters;
txt2 = "an arbitrary path" // Characters;
f[t_] := {Cos[2 \[Pi] t], Sin[6 \[Pi] t]};
totalarclength = NIntegrate[Sqrt[f'[\[Tau]].f'[\[Tau]]], {\[Tau], 0, 1}];
invarclength = First@NDSolve[{D[$t[s], s] == 1/Sqrt[f'[$t[s]].f'[$t[s]]], ...
9
Great answers have already appeared. In the spirit of demonstrating multiple solutions to a problem with Mathematica, I would like to offer one using a different approach.
First, some geometric analysis. This great circle bounds a hemisphere lying in a half-space determined by a normal direction to the circle's plane. Letting $\theta$ be the latitude at ...
9
AbsoluteOptions is known as very buggy function and the bug in determining the true PlotRange has very long history...
You could try my Ticks-based workaround for getting the complete PlotRange (with PlotRangePadding added):
completePlotRange[plot:(_Graphics|_Graphics3D)] :=
Quiet@Last@
Last@Reap[
Rasterize[
Show[plot, Axes -> True, ...
8
If you have v9, here's an alternative solution: first I calculate the gradient and gradient orientation for each pixel
gray = ColorConvert[img, "Grayscale"];
orientation = GradientOrientationFilter[gray, 3];
gradient = GradientFilter[gray, 3];
then I create a weighted histogram from those:
wd = WeightedData[Flatten[ImageData[orientation]],
...
6
Surely a better solution exists! Assuming m your matrix.
m = RandomReal[1, {1000, 1000}];
pat = Array[(-1)^# &, First@Dimensions[m]];
B1 = (pat #) & /@ Reverse[m, {1, 2}]; // AbsoluteTiming
{0.124800, Null}
Though Table is intuitive but will be pretty slow for big lists.
u = Length[m];
B = Table[
m[[u - r, u - s]]*(-1)^(s + 1), {r, 0, u - ...
5
As an addition to @bills's answer you can rotate by the mean of the slope of all the detected lines.
slopeLine = slope @@@ lines
meanslope =
Mean@Join[Select[slopeLine, # > -1 &],
Select[slopeLine, # < -1 &] + Pi/2]
ImageRotate[img, -meanslope]
5
On many platforms, matrix operations are really fast, so using them is a good idea. (You have to get their dimensions correct, though!)
SparseArray objects are likely to be efficient in RAM and time usage. All we have to do is code the rules used to generate the right and left matrices:
arrange[c_] := Block[{m, n, sa},
{m, n} = Dimensions[c];
...
4
If the problem is that the transformation function is slow to compute, a simple way to create and use a look-up table is to memoize the function:
(* create an example image *)
image = RandomImage[1, {30, 20}, ColorSpace -> "RGB"] ~ ImageResize ~ Scaled[10]
(* define the transformation function with memoization *)
mem : func[{x_, y_}] := mem = {x + 0.01 ...
4
A completely stupid workaround that perhaps someone knows how to automate:
Create a Graphics object
Graphics[{GeometricTransformation[Rectangle[], RotationTransform[1.]]}]
Right click the Graphics and select Get Coordinates
Drag around a bit in the graphics
AbsoluteOptions[< Put the object here >, PlotRange] gives the correct PlotRange
It also ...
3
You could use Reverse for the first part and define a helper function to do the rest :
rM[avector_, {m1_, m2_}] :=
Module[{nc, local, rules},
nc = Length[avector]/2;
local = {m1, m2} # & /@ Partition[avector, 2];
Flatten[ReplacePart[local, (# -> local[[ nc + 1 - #]]) & /@ Range[nc]], 1]
]
The argument {m1, m2} will be used to multiply ...
3
ImageTransformation works with functions, not tables. It should be straightforward to define a function that carries out the same transformation as the table, but you will need to be aware that the #[[1]] and #[[2]] arguments go from 0 to 1 (across the image) so you will need to design the function to handle this input range. For example, you might want a ...
3
arrngF1 = MapAt[-1 # &,
#[[Range[Dimensions[#][[1]], 1, -1],
Join @@ Reverse@Partition[Range[Dimensions[#][[2]]], {2}]]],
{;; , 2 ;; ;; 2}] &;
arrngF2 = Module[{temp = #[[Range[Dimensions[#][[1]], 1, -1],
Join @@ Reverse@Partition[Range[Dimensions[#][[2]]], {2}]]]},
temp[[;; , 2 ;; ;; 2]] = (-1) temp[[;; , 2 ;; ;; 2]]; temp] &;
...
2
I think you have to make sure that your transformation function always handles input cleanly. Here's a test you can do to see what goes into your function. (And I think you can use real coordinates if you use the DataRange option.)
i = ImageResize[ExampleData[{"TestImage", "Mandrill"}], {20, 20}];
The function:
f[pt_] := (Print[pt]; {pt[[1]], pt[[2]]});
...
1
There is a Wolfram Blog post that explains this as a subproblem:
Mapping GPS Data, by Robert Raguet-Schofield.
That was published in 2009 and I think is pretty nifty. But I'd recommend looking into out new URLFetchAsynchronous and perhaps updating the code. Below you see parts in the blog where he seamlessly goes from patches to a single map:
1
Ok,
I feel sorry for myself by now... This was easier than I thought... So here's my proposition for a solution :
Given matrix $\mathbf A$ written in mathematica as :
A = {{a, b, i, j}, {c, d, k, l}, {e, f, m, n}, {g, h, o, p}}
To obtain matrix $\mathbf B$ I did this :
u = Length[A];
B = Table[A[[u - r, u - s]]*(-1)^(s + 1), {r, 0, u-1}, {s, 0, u-1}]
...
1
I don't know why Normal does not work, but you can perform at least the transformation shown like this:
pts = {{-0.36551249999999996`, -0.29021463333333336`}, \
{-0.36509784999999995`, -0.2812481916666667`}, {-0.3619309499999999`, \
-0.2645122083333334`}, {-0.3592788999999999`, -0.25668636666666667`}, \
{-0.3520880999999999`, -0.2419782333333334`}, ...
Only top voted, non community-wiki answers of a minimum length are eligible
