POV-Ray image map on a curved surface - image

First of all, I have this code which creates a curved surface that looks like a flying carpet.
#include "colors.inc"
camera {
location <5,140,25>
look_at <0, 0, 0>
angle 7}
light_source {
<20, 20, 20>
White
}
#declare Ball =
sphere{<0,0,0>,0.25
texture{
pigment{color rgb<1,0.65,0.0>}
finish {diffuse 0.9 phong 1}
}// end of texture
}// end of sphere
#declare E = 5;
#declare Z = -E; // start value Z
#declare EndZ = E; // end value Z
#declare Step = 0.2;// step value
//------- loop start Z:
#while ( Z < EndZ + Step)
#declare X = -E; // start value X
#declare EndX = E; // end value X
//------ loop start X:
#while ( X < EndX + Step)
object{Ball
translate<X,0.05*X*sin(X-2*Z)
+ 0.1*Z*cos(3*X-Z),Z>}
#declare X = X+Step;//next X value
#end // --------------- loop end X
#declare Z = Z+Step;//next Z value
#end // --------------- loop end Z
The output of this code:
now I want to map an simple image like this
Instead of yellow balls, I want map that simple pattern on the curved surface so that pattern can be wavy kind of looking.
I have tried to map the ball and loop it, but obviously the output was not the single square wave-looking image. (I don't want that picture repeated, just single curved image.)
would that be possible??
Thank you..

Currently you pre-declare a sphere and then translate it. If you apply a texture then it will be translated along with the sphere, so all will get the same texture.
Use the loop to create the sphere with the proper coordinates at once, inside a union. Then apply the texture to that union. Scale and position the texture accordingly.

Related

Rotating the plot of a spiral in IDL

I'm trying to rotate the spiral with equation r = -theta/A, with A=50*(!PI/180) around its centre. However, when I exceed a 90 degrees rotation, the middle part of the spiral disappears. Is there a way to avoid that?
Thanks in advance for the help. Here's the code I'm using:
w = -FINDGEN(3600)*(!PI/1800.)
A = 50.*(!PI/180.)
a_ = -4.97731628529286 ;angle by which I want to rotate
plot_PS1 = POLARPLOT(P_Spiral(w + a_), w, $
TITLE='Parker Spiral, r [AU], $\theta$ [rad]', $
COLOR='blue', THICK=3)
plot_PS2 = POLARPLOT( P_Spiral(-w - a_), w,$
COLOR='blue', /OVERPLOT, THICK=3)
end
function P_Spiral, tau
compile_opt strictarr
A_ = 50.*(!PI/180.)
return, -tau/A_
end

Animation of circle - curve

Im creating animation of circle in JavaFX. A user inputs variables like angle and power of throw and my task was to create trajectory of this and make animation of thrown circle. Already I did trajectory and with that Im able to get final position of circle, but I still need to do animation of cricle trajectory.
Im calculating the whole trajectory in loop and then draw curve.
Circle on the left is before throw and the right one is after this action. How can I animate this circle with trajectory already drawn?
https://i.imgur.com/HlxQD8r.png
for(x = 0; x < Z; x=x+0.01){
y = x * Math.tan(angleRadians) - (gSpeed/mianownik) * Math.pow(x, 2); // some variables to calculate y position
y = 0 - y; //negation the real y position cause its kinda reverted
gc.strokeLine(x+10, y+100, x+10,y+100); // drawing line; +10 and +100 because (10, 100) is circle starting position
}
gc.fillOval(x,y+100,20,20); // drawing cricle after throw

convert an image from Cartesian to Polar

I'm trying to convert an image with many circles with the same center, from Cartesian to Polar (so that the new image will be the circles but lines instead of the circles, see the image below), and that's working out just fine using the following code:
[r, c] = size(img);
r=floor(r/2);
c=floor(c/2);
[X, Y] = meshgrid(-c:c-1,-r:r-1);
[theta, rho] = cart2pol(X, Y);
subplot(221), imshow(img), axis on;
hold on;
subplot(221), plot(xCenter,yCenter, 'r+');
subplot(222), warp(theta, rho, zeros(size(theta)), img);
view(2), axis square;
The problem is, I don't understand why does it even work? (obviously it's not my code), I mean, when I use the function cart2pol I don't even use the image, it's just some vectors x and y generated from the meshgrid function..
and another problem is, I want somehow to have a new image (not just to be able to draw it with the wrap function) which is the original image but by the theta and rho coordinates (meaning the same pixels but rearranged)... I'm not even sure how to ask this, in the end I want to have an image which is a matrix so that I can sum each row and turn the matrix into a column vector...
You can think of your image as being a 2D matrix, where each pixel has an X and Y coordinate
[(1,1) (1,2) (1,3) .... (1,c)]
[(2,1) (2,2) (2,3) .... (2,c)]
[(3,1) (3,2) (3,3) .... (3,c)]
[.... .... .... .... .... ]
[(r,1) (r,2) (r,3) .... (r,c)]
In the code that you posted, it maps each of these (X,Y) coordinates to it's equivalent polar coordinate (R, theta) using the center of the image floor(c/2) and floor(r/2) as the reference point.
% Map pixel value at (1,1) to it's polar equivalent
[r,theta] = cart2pol(1 - floor(r/2),1 - floor(c/2));
So whatever pixel value was used for (1,1) should now appear in your new polar coordinate space at (r,theta). It is important to note that to do this conversion, no information about the actual pixel values in the image matters, rather we just want to perform this transformation for each pixel within the image.
So first we figure out where the center of the image is:
[r, c] = size(img);
r = floor(r / 2);
c = floor(c / 2);
Then we figure out the (X,Y) coordinates for every point in the image (after the center has already been subtracted out
[X, Y] = meshgrid(-c:c-1,-r:r-1);
Now convert all of these cartesian points to polar coordinates
[theta, rho] = cart2pol(X, Y);
All that warp now does, is say "display the value of img at (X,Y) at it's corresponding location in (theta, rho)"
warp(theta, rho, zeros(size(theta)), img);
Now it seems that you want a new 2D image where the dimensions are [nTheta, nRho]. To do this, you could use griddata to interpolate your scattered (theta, rho) image (which is displayed by warp above) to a regular grid.
% These is the spacing of your radius axis (columns)
rhoRange = linspace(0, max(rho(:)), 100);
% This is the spacing of your theta axis (rows)
thetaRange = linspace(-pi, pi, 100);
% Generate a grid of all (theta, rho) coordinates in your destination image
[T,R] = meshgrid(thetaRange, rhoRange);
% Now map the values in img to your new image domain
theta_rho_image = griddata(theta, rho, double(img), T, R);
Take a look at all the interpolation methods for griddata to figure out which is most appropriate for your scenario.
There were a couple other issues (like the rounding of the center) which caused the result to be slightly incorrect. A fully working example is provided below
% Create an image of circles
radii = linspace(0, 40, 10);
rows = 100;
cols = 100;
img = zeros(rows, cols);
for k = 1:numel(radii)
t = linspace(0, 2*pi, 1000);
xx = round((cos(t) * radii(k)) + (cols / 2));
yy = round((sin(t) * radii(k)) + (rows / 2));
toremove = xx > cols | xx < 1 | yy > rows | yy < 1;
inds = sub2ind(size(img), xx(~toremove), yy(~toremove));
img(inds) = 1;
end
[r,c] = size(img);
center_row = r / 2;
center_col = c / 2;
[X,Y] = meshgrid((1:c) - center_col, (1:r) - center_row);
[theta, rho] = cart2pol(X, Y);
rhoRange = linspace(0, max(rho(:)), 1000);
thetaRange = linspace(-pi, pi, 1000);
[T, R] = meshgrid(thetaRange, rhoRange);
theta_rho_image = griddata(theta, rho, double(img), T, R);
figure
subplot(1,2,1);
imshow(img);
title('Original Image')
subplot(1,2,2);
imshow(theta_rho_image);
title('Polar Image')
And the result

Applying SAD on image using matlab

Hello so I have an original image and I cropped a part of that image(template) and wrote a code with SAD algorithim to detect on the original image the part i cropped (template) where it exists and draw a rectangle on it.
The code doesnt have any errors , but the rectangle draw doesnt match the template , so I guess the 'output ' variable is the problem can you please help me
I2=imread('img.PNG');
I2=rgb2gray(I2);
[r,c]= size(I2);
%padding the image
%padding
B = padarray(I2,[24 24],'replicate' ,'both');
%imshow(B);
%creating template
temp=imread('crop_img.PNG');
temp= rgb2gray(temp);
%imshow(temp)
size(temp)
output = zeros (size(I2));
K = size(temp)
x=1;
y=1;
for i = 25 : r-24
for j = 25: c-24
%dif = temp -I2(i:i+47,j:j+47) ;
K = imabsdiff(temp,B(i-24:i+24,j-24:j+24));
output(i-24, j-24) = sum (K(:));
end
end
%gettting min value in output
min_value = output(1,1)
for i=1 : r
for j=1 :c
if(output(i,j)<min_value)
min_value=output(i,j);
row=i;
col=j;
end
end
end
row
col
output(1,465)
output(6,200)
%draw rectangle on matching area
%Create the shape inserter object.
shapeInserter = vision.ShapeInserter;
%Define the rectangle dimensions as [x y width height].
rectangle = int32([row col 24 24]);
%Draw the rectangle and display the result.
J = step(shapeInserter, I2, rectangle);
imshow(J);
There is an issue with image coordinates vs. matrix coordinates - you need to flip your row and column variables. Also, with shapeInserter, the coordinates are for the corner of the rectangle, so to make something centred on your output, you'd need something along the lines of:
rectangle = uint8([col-12 row-12 24 24]);
In MATLAB, it is usually not required to loop over every pixel of an image - it's much more efficient to work on the whole image at once. For example, you don't need a loop here:
min_value = output(1,1)
for i=1 : r
for j=1 :c
if(output(i,j)<min_value)
min_value=output(i,j);
row=i;
col=j;
end
end
end
This can be replaced by:
min_value = min(output(:));
[row,col] = find(output==min_value,1,'first');

Ellipse Detection using Hough Transform

using Hough Transform, how can I detect and get coordinates of (x0,y0) and "a" and "b" of an ellipse in 2D space?
This is ellipse01.bmp:
I = imread('ellipse01.bmp');
[m n] = size(I);
c=0;
for i=1:m
for j=1:n
if I(i,j)==1
c=c+1;
p(c,1)=i;
p(c,2)=j;
end
end
end
Edges=transpose(p);
Size_Ellipse = size(Edges);
B = 1:ceil(Size_Ellipse(1)/2);
Acc = zeros(length(B),1);
a1=0;a2=0;b1=0;b2=0;
Ellipse_Minor=[];Ellipse_Major=[];Ellipse_X0 = [];Ellipse_Y0 = [];
Global_Threshold = ceil(Size_Ellipse(2)/6);%Used for Major Axis Comparison
Local_Threshold = ceil(Size_Ellipse(1)/25);%Used for Minor Axis Comparison
[Y,X]=find(Edges);
Limit=numel(Y);
Thresh = 150;
Para=[];
for Count_01 =1:(Limit-1)
for Count_02 =(Count_01+1):Limit
if ((Count_02>Limit) || (Count_01>Limit))
continue
end
a1=Y(Count_01);b1=X(Count_01);
a2=Y(Count_02);b2=X(Count_02);
Dist_01 = (sqrt((a1-a2)^2+(b1-b2)^2));
if (Dist_01 >Global_Threshold)
Center_X0 = (b1+b2)/2;Center_Y0 = (a1+a2)/2;
Major = Dist_01/2.0;Alpha = atan((a2-a1)/(b2-b1));
if(Alpha == 0)
for Count_03 = 1:Limit
if( (Count_03 ~= Count_01) || (Count_03 ~= Count_02))
a3=Y(Count_03);b3=X(Count_03);
Dist_02 = (sqrt((a3 - Center_Y0)^2+(b3 - Center_X0)^2));
if(Dist_02 > Local_Threshold)
Cos_Tau = ((Major)^2 + (Dist_02)^2 - (a3-a2)^2 - (b3-b2)^2)/(2*Major*Dist_02);
Sin_Tau = 1 - (Cos_Tau)^2;
Minor_Temp = ((Major*Dist_02*Sin_Tau)^2)/(Major^2 - ((Dist_02*Cos_Tau)^2));
if((Minor_Temp>1) && (Minor_Temp<B(end)))
Acc(round(Minor_Temp)) = Acc(round(Minor_Temp))+1;
end
end
end
end
end
Minor = find(Acc == max(Acc(:)));
if(Acc(Minor)>Thresh)
Ellipse_Minor(end+1)=Minor(1);Ellipse_Major(end+1)=Major;
Ellipse_X0(end+1) = Center_X0;Ellipse_Y0(end+1) = Center_Y0;
for Count = 1:numel(X)
Para_X = ((X(Count)-Ellipse_X0(end))^2)/(Ellipse_Major(end)^2);
Para_Y = ((Y(Count)-Ellipse_Y0(end))^2)/(Ellipse_Minor(end)^2);
if (((Para_X + Para_Y)>=-2)&&((Para_X + Para_Y)<=2))
Edges(X(Count),Y(Count))=0;
end
end
end
Acc = zeros(size(Acc));
end
end
end
Although this is an old question, perhaps what I found can help someone.
The main problem of using the normal Hough Transform to detect ellipses is the dimension of the accumulator, since we would need to vote for 5 variables (the equation is explained here):
There is a very nice algorithm where the accumulator can be a simple 1D array, for example, and that runs in . If you wanna see code, you can look at here (the image used to test was that posted above).
If you use circle for rough transform is given as rho = xcos(theta) + ysin(theta)
For ellipse since it is
You could transform the equation as
rho = axcos(theta) + bysin(theta)
Although I am not sure if you use standard Hough Transform, for ellipse-like transforms, you could manipulate the first given function.
If your ellipse is as provided, being a true ellipse and not a noisy sample of points;
the search for the two furthest points gives the ends of the major axis,
the search for the two nearest points gives the ends of the minor axis,
the intersection of these lines (you can check it's a right angle) occurs at the centre.
If you know the 'a' and 'b' of an ellipse then you can rescale the image by factor of a/b in one direction and look for circle. I am still thinking about what to do when a and b are unknown.
If you know that it is circle then use Hough transform for circles. Here is a sample code:
int accomulatorResolution = 1; // for each pixel
int minDistBetweenCircles = 10; // In pixels
int cannyThresh = 20;
int accomulatorThresh = 5*_accT+1;
int minCircleRadius = 0;
int maxCircleRadius = _maxR*10;
cvClearMemStorage(storage);
circles = cvHoughCircles( gryImage, storage,
CV_HOUGH_GRADIENT, accomulatorResolution,
minDistBetweenCircles,
cannyThresh , accomulatorThresh,
minCircleRadius,maxCircleRadius );
// Draw circles
for (int i = 0; i < circles->total; i++){
float* p = (float*)cvGetSeqElem(circles,i);
// Draw center
cvCircle(dstImage, cvPoint(cvRound(p[0]),cvRound(p[1])),
1, CV_RGB(0,255,0), -1, 8, 0 );
// Draw circle
cvCircle(dstImage, cvPoint(cvRound(p[0]),cvRound(p[1])),
cvRound(p[2]),CV_RGB(255,0,0), 1, 8, 0 );
}

Resources