Related
I'm developing a procedural map using gridmap 3D in Godot,
set_cell_item(x: int, y: int, z: int, item: int, orientation: int = 0)
On the last property I can setup the orientation, of the object... but it looks like it ranges from -1 to 1...so, only 3 options?
Using then make my tile rotate in the Z axis, and I want it to rotate on the y axis. The docs point me to
get_orthogonal_index()
But I dindt understand how to use it
The value goes from 0 to 24, where 0 is no rotation. The documentation of get_orthogonal_index says:
This function considers a discretization of rotations into 24 points on unit sphere, lying along the vectors (x,y,z) with each component being either -1, 0, or 1, and returns the index of the point best representing the orientation of the object. It is mainly used by the GridMap editor. For further details, refer to the Godot source code.
What the 24 rotations are is not easy to visualize. However, suffice to say they are the The Rotational Symmetries of the Cube. In other words, they are all the ways you can take a nondescript cube and rotate it, such that it looks the same after the rotation (it is rotated, but being a nondescript cube, it looks the same).
Now, the issue is in what order are these rotations?
Well, wonder no more, thanks to the magic of looking at Godot source code, these are the rotations:
// --- x --- --- y --- --- z ---
Basis( 1, 0, 0, 0, 1, 0, 0, 0, 1), // 0
Basis( 0, -1, 0, 1, 0, 0, 0, 0, 1), // 1
Basis(-1, 0, 0, 0, -1, 0, 0, 0, 1), // 2
Basis( 0, 1, 0, -1, 0, 0, 0, 0, 1), // 3
Basis( 1, 0, 0, 0, 0, -1, 0, 1, 0), // 4
Basis( 0, 0, 1, 1, 0, 0, 0, 1, 0), // 5
Basis(-1, 0, 0, 0, 0, 1, 0, 1, 0), // 6
Basis( 0, 0, -1, -1, 0, 0, 0, 1, 0), // 7
Basis( 1, 0, 0, 0, -1, 0, 0, 0, -1), // 8
Basis( 0, 1, 0, 1, 0, 0, 0, 0, -1), // 9
Basis(-1, 0, 0, 0, 1, 0, 0, 0, -1), // 10
Basis( 0, -1, 0, -1, 0, 0, 0, 0, -1), // 11
Basis( 1, 0, 0, 0, 0, 1, 0, -1, 0), // 12
Basis( 0, 0, -1, 1, 0, 0, 0, -1, 0), // 13
Basis(-1, 0, 0, 0, 0, -1, 0, -1, 0), // 14
Basis( 0, 0, 1, -1, 0, 0, 0, -1, 0), // 15
Basis( 0, 0, 1, 0, 1, 0, -1, 0, 0), // 16
Basis( 0, -1, 0, 0, 0, 1, -1, 0, 0), // 17
Basis( 0, 0, -1, 0, -1, 0, -1, 0, 0), // 18
Basis( 0, 1, 0, 0, 0, -1, -1, 0, 0), // 19
Basis( 0, 0, 1, 0, -1, 0, 1, 0, 0), // 20
Basis( 0, 1, 0, 0, 0, 1, 1, 0, 0), // 21
Basis( 0, 0, -1, 0, 1, 0, 1, 0, 0), // 22
Basis( 0, -1, 0, 0, 0, -1, 1, 0, 0) // 23
These are Basis. They describe the orientation by specifying the direction of the axis.
The three first numbers are the x axis, followed by three numbers for the y axis, and three more for the z axis.
The first one, is no rotation at all:
Basis( 1, 0, 0, 0, 1, 0, 0, 0, 1), // 0
Notice that the x axis is 1,0,0, which means it is oriented towards the x. The y axis is 0,1,0… you guested oriented towards the y, and 0,0,1 for the z being just the z. So no rotation, as expected.
As you can see the first four indexes gives you rotation that keep the z axis untouched. Thus, you see rotation around the z axis.
Since you want rotation around the y axis, let us pick the ones that keep the y axis untouched:
Basis( 1, 0, 0, 0, 1, 0, 0, 0, 1), // 0
Basis(-1, 0, 0, 0, 1, 0, 0, 0, -1), // 10
Basis( 0, 0, 1, 0, 1, 0, -1, 0, 0), // 16
Basis( 0, 0, -1, 0, 1, 0, 1, 0, 0), // 22
As per the order… 0 is no rotation. 10 is half turn, since the other axis are flipped. Thus, either 0, 22, 10, 16 or 0, 16, 10, 22, depending if you want a positive or negative rotation.
I have defined a rotation matrix and wanted the Eigen::Transform to perform rotation. For some reason, it is still set at identity although I am rotating it.
//Definig my rotation matrix
Eigen::Matrix3f roll_rotation_matrix( 3, 3 );
roll_rotation_matrix << 1, 0, 0, 0, 0, 1, 0, -1, 0;
//Print
display("PRINT ROLL ROTATION: ")
display(roll_rotation_matrix)
// Perform rotation along X
display("BEFORE: ")
display(roll_input_stamped_transform.transform.rotation())
//Rotate the rotation matrix
roll_input_stamped_transform.transform.rotate( roll_rotation_matrix );
roll_input_stamped_transform.transform.rotation = roll_rotation_matrix;
//Print
display(" AFTER: ")
display(roll_input_stamped_transform.transform.rotation());
And my output here is as below:
PRINT ROLL ROTATION:
1 0 0
0 0 1
0 -1 0
BEFORE:
1 0 0
0 1 0
0 0 1
AFTER:
1 0 0
0 1 0
0 0 1
As I am printing my roll_rotation_matrix, I can see that my matrix is not identity. But, even after applying rotate(), the rotation matrix still seems to be at identity.
Do you guys have any clue as to what might me going on here?
Figured out the issue.
I had to set the roll_input_stamped_transform.transform.setIdentity() in order for it to apply my rotation matrix.
I think of the 2D array as a coordinate and try to find a coordinate value with a value of 1.
So far, it's a very easy BFS problem, but what I want to do is look at the following picture.
While I'm looking for 1 or after I've found it all, I would like to know the coordinate values surrounding the boundary in the order of the arrow or the other direction.
What options do I need to add to get those information?
Below is the BFS code that I use now. I can get coordinate values from the BFS function as shown in the second picture.
class Node
{
public int x;
public int y;
public Node(int x, int y)
{
this.x = x;
this.y = y;
}
};
private int[] dx = new int[8] { -1, 0, 1, 0, 1, -1, -1, 1 };
private int[] dy = new int[8] { 0, -1, 0, 1, 1, -1, 1, -1 };
private Queue<Node> q = new Queue<Node>();
bool[,] visit = new bool[15, 15];
int[,] coordinates = new int[15, 15] { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 },
{ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
{ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
{ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
{ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }};
void BFS(int[,] pixel, int x, int y)
{
q.Enqueue(new Node(x, y));
visit[x, y] = true;
while (q.Count != 0)
{
Node cur = q.Dequeue();
for (int i = 0; i < 8; i++)
{
int r = cur.x + dx[i];
int c = cur.y + dy[i];
if (r >= 0 && c >= 0 && r < 15 && c < 15)
{
if (!visit[r, c] && pixel[r, c] == 1)
{
q.Enqueue(new Node(r, c));
visit[r, c] = true;
}
}
}
}
}
void main()
{
for (int y = 0; y < 15; y++)
{
for (int x = 0; x < 15; x++)
{
if (!visit[x, y] && coordinates[x, y] == 1)
{
BFS(coordinates, x, y);
}
}
}
}
we do not need BFS for finding boundary '1' values. We can simply loop over 2D grid and then for each '1', we can just check whether all of it's 4 adjacent (i.e up, down, left, right) values are '1' or not. If at least one of them is not '1', then it is a boundary point. Thanks!
find a coordinate value with a value of 1
Start by pre-processing the matrix
- Search all 1 values (this can also be done recursively)
- If 1 value does not have a 0 neighbor, it means it it not on edge - change it to 0.
After the pre-processing you are left with only the edge 1 values, and all others are 0.
I would like to know the coordinate values surrounding the boundary in
the order of the arrow or the other direction
To find out if the edge forms a closed loop, and get the nodes in the right order
apply BFS to the pre-processed matrix.
Seek a path from a node of your choice, back to the same node(a loop).
Using the excellent guide by Nadieh Bremer I'm making a stretched chord diagram.
However, with certain data inputs the rendering goes awry.
I've made a demo to demonstrate my issue here:
https://codepen.io/benmayocode/pen/MPEwdr
Specifically, in the .js file lines 269 to 281 file I have:
var respondents = 40,
emptyPerc = 0.4,
emptyStroke = Math.round(respondents*emptyPerc);
var Names = ['BEN', 'ROSE', '', '1', '2', '6', ''];
var matrix = [
[0, 0, 0, 10, 10, 0, 0] ,
[0, 0, 0, 0, 10, 10, 0] ,
[0, 0, 0, 0, 0, 0, 24] ,
[10, 0, 0, 0, 0, 0, 0] ,
[10, 10, 0, 0, 0, 0, 0] ,
[0, 10, 0, 0, 0, 0, 0] ,
[0, 0, 0, 24, 0, 0, 0] ,
];
This renders incorrectly - but if I change it to...
var respondents = 40,
emptyPerc = 0.4,
emptyStroke = Math.round(respondents*emptyPerc);
var Names = ['BEN', 'LIB', 'ROSE', '', '1', '2', '6', ''];
var matrix = [
[0, 0, 0, 0, 10, 10, 0, 0] ,
[0, 0, 0, 0, 0, 10, 0, 0] ,
[0, 0, 0, 0, 0, 10, 10, 0] ,
[0, 0, 0, 0, 0, 0, 0, 24] ,
[10, 0, 0, 0, 0, 0, 0, 0] ,
[10, 10, 10, 0, 0, 0, 0, 0] ,
[0, 0, 10, 0, 0, 0, 0, 0] ,
[0, 0, 0, 0, 24, 0, 0, 0] ,
];
Then it works great. I obviously see the difference between the two blocks of code, but why are they producing different results, and is it possible to modify my code to accommodate both examples?
If you examine the dodgy arc, you will see you can flip it into the right place by altering the sign on the transform from (50,0) to (-50,0). If you then look at the code that assigns the transform, it is
.attr("transform", function(d, i) {
d.pullOutSize = pullOutSize * ( d.startAngle + 0.01 > Math.PI ? -1 : 1);
return "translate(" + d.pullOutSize + ',' + 0 + ")";
});
with a note in the original text to say that "the 0.01 is for rounding errors". Given that the startAngle is already 3.13--i.e. very close to Pi--it looks like this is an edge case where the value fell just the wrong side of the cutoff. Changing the allowable rounding error value to 0.02 puts the arc in the correct place, or you could do something like
d.pullOutSize = pullOutSize * (
// is the start angle less than Pi?
d.startAngle + 0.01 < Math.PI ? 1 :
// if yes, is the end angle also less than Pi?
d.endAngle < Math.PI ? 1 : -1 );
to prevent edge cases like that in your dataset.
I wish to read image description text from the image property tab (right click) with c++ or python.
Is there anyway to do it?
Looks like Opencv is not supporting it, I guess.
BTW, my OS is ubuntu 16.04.
Thanks,
If you are on Ubuntu, you probably have ImageMagick installed and that has a program called identify within the suite. You can just run the following in a Terminal at the command-line, or you could run a Python subprocess and grab its output:
identify -verbose someImage.jpg
Sample Output
Image: /Users/mark/Desktop/IMG_2326.JPG
Format: JPEG (Joint Photographic Experts Group JFIF format)
Mime type: image/jpeg
Class: DirectClass
Geometry: 3264x2448+0+0
Resolution: 72x72
Print size: 45.3333x34
Units: PixelsPerInch
Type: TrueColor
Endianess: Undefined
Colorspace: sRGB
Depth: 8-bit
Channel depth:
Red: 8-bit
Green: 8-bit
Blue: 8-bit
Channel statistics:
Pixels: 7990272
Red:
min: 0 (0)
max: 255 (1)
mean: 139.125 (0.545587)
standard deviation: 62.0934 (0.243503)
kurtosis: -0.948773
skewness: -0.255567
entropy: 0.980761
Green:
min: 0 (0)
max: 255 (1)
mean: 129.827 (0.509124)
standard deviation: 63.4802 (0.248942)
kurtosis: -0.744472
skewness: -0.322559
entropy: 0.978628
Blue:
min: 0 (0)
max: 255 (1)
mean: 121.768 (0.477522)
standard deviation: 63.6425 (0.249578)
kurtosis: -1.14208
skewness: 0.0243162
entropy: 0.980614
Image statistics:
Overall:
min: 0 (0)
max: 255 (1)
mean: 130.24 (0.510744)
standard deviation: 63.4733 (0.248915)
kurtosis: -0.968273
skewness: -0.18575
entropy: 0.980001
Rendering intent: Perceptual
Gamma: 0.454545
Chromaticity:
red primary: (0.64,0.33)
green primary: (0.3,0.6)
blue primary: (0.15,0.06)
white point: (0.3127,0.329)
Matte color: grey74
Background color: white
Border color: srgb(223,223,223)
Transparent color: none
Interlace: None
Intensity: Undefined
Compose: Over
Page geometry: 3264x2448+0+0
Dispose: Undefined
Iterations: 0
Compression: JPEG
Quality: 96
Orientation: TopLeft
Properties:
date:create: 2017-05-31T13:53:16+01:00
date:modify: 2014-09-23T08:22:25+01:00
exif:ApertureValue: 4845/1918
exif:BrightnessValue: 6155/1061
exif:ColorSpace: 1
exif:ComponentsConfiguration: 1, 2, 3, 0
exif:DateTime: 2014:09:23 08:22:25
exif:DateTimeDigitized: 2014:09:23 08:22:25
exif:DateTimeOriginal: 2014:09:23 08:22:25
exif:ExifImageLength: 2448
exif:ExifImageWidth: 3264
exif:ExifOffset: 204
exif:ExifVersion: 48, 50, 50, 49
exif:ExposureMode: 0
exif:ExposureProgram: 2
exif:ExposureTime: 1/120
exif:Flash: 24
exif:FlashPixVersion: 48, 49, 48, 48
exif:FNumber: 12/5
exif:FocalLength: 103/25
exif:FocalLengthIn35mmFilm: 33
exif:GPSAltitude: 10003/299
exif:GPSAltitudeRef: 0
exif:GPSInfo: 946
exif:GPSLatitude: 51/1, 51/1, 347/100
exif:GPSLatitudeRef: N
exif:GPSLongitude: 2/1, 12/1, 1992/100
exif:GPSLongitudeRef: W
exif:GPSTimeStamp: 7/1, 22/1, 2456/100
exif:ISOSpeedRatings: 64
exif:Make: Apple
exif:MakerNote: 65, 112, 112, 108, 101, 32, 105, 79, 83, 0, 0, 1, 77, 77, 0, 6, 0, 1, 0, 9, 0, 0, 0, 1, 0, 0, 0, 0, 0, 3, 0, 7, 0, 0, 0, 104, 0, 0, 0, 92, 0, 4, 0, 9, 0, 0, 0, 1, 0, 0, 0, 1, 0, 5, 0, 9, 0, 0, 0, 1, 0, 0, 0, 208, 0, 6, 0, 9, 0, 0, 0, 1, 0, 0, 0, 218, 0, 7, 0, 9, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 98, 112, 108, 105, 115, 116, 48, 48, 212, 1, 2, 3, 4, 5, 6, 7, 8, 89, 116, 105, 109, 101, 115, 99, 97, 108, 101, 85, 101, 112, 111, 99, 104, 85, 118, 97, 108, 117, 101, 85, 102, 108, 97, 103, 115, 18, 59, 154, 202, 0, 16, 0, 19, 0, 0, 18, 143, 64, 67, 109, 189, 16, 1, 8, 17, 27, 33, 39, 45, 50, 52, 61, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 63
exif:MeteringMode: 5
exif:Model: iPhone 5
exif:Orientation: 1
exif:ResolutionUnit: 2
exif:SceneCaptureType: 0
exif:SceneType: 1
exif:SensingMethod: 2
exif:ShutterSpeedValue: 5567/806
exif:Software: 7.1.2
exif:SubjectArea: 1631, 1223, 1795, 1077
exif:SubSecTimeDigitized: 918
exif:SubSecTimeOriginal: 918
exif:thumbnail:Compression: 6
exif:thumbnail:JPEGInterchangeFormat: 1210
exif:thumbnail:JPEGInterchangeFormatLength: 12195
exif:thumbnail:ResolutionUnit: 2
exif:thumbnail:XResolution: 72/1
exif:thumbnail:YResolution: 72/1
exif:WhiteBalance: 0
exif:XResolution: 72/1
exif:YCbCrPositioning: 1
exif:YResolution: 72/1
jpeg:colorspace: 2
jpeg:sampling-factor: 2x2,1x1,1x1
signature: 84dc83ac4ff07920155036d321be9b8fe687be8b5eb68a76e20518b3e6f048f8
unknown: 103/25, 103/25, 12/5, 12/5
Profiles:
Profile-exif: 16380 bytes
Artifacts:
verbose: true
Tainted: False
Filesize: 3.9071MiB
Number pixels: 7.99027M
Pixels per second: 47.0016MB
User time: 0.150u
Elapsed time: 0:01.170
Version: ImageMagick 7.0.5-6 Q16 x86_64 2017-05-15 http://www.imagemagick.org
Another option is exiftool, which you run like this at the command-line, and which you could also run as a subprocess in Python:
exiftool ~/Desktop/IMG_2326.JPG
Sample Output
ExifTool Version Number : 10.50
File Name : IMG_2326.JPG
Directory : /Users/mark/Desktop
File Size : 3.9 MB
File Modification Date/Time : 2014:09:23 08:22:25+01:00
File Access Date/Time : 2017:05:31 13:57:20+01:00
File Inode Change Date/Time : 2017:05:31 13:53:16+01:00
File Permissions : rw-------
File Type : JPEG
File Type Extension : jpg
MIME Type : image/jpeg
Exif Byte Order : Big-endian (Motorola, MM)
Make : Apple
Camera Model Name : iPhone 5
Orientation : Horizontal (normal)
X Resolution : 72
Y Resolution : 72
Resolution Unit : inches
Software : 7.1.2
Modify Date : 2014:09:23 08:22:25
Y Cb Cr Positioning : Centered
Exposure Time : 1/120
F Number : 2.4
Exposure Program : Program AE
ISO : 64
Exif Version : 0221
Date/Time Original : 2014:09:23 08:22:25
Create Date : 2014:09:23 08:22:25
Components Configuration : Y, Cb, Cr, -
Shutter Speed Value : 1/120
Aperture Value : 2.4
Brightness Value : 5.801131008
Metering Mode : Multi-segment
Flash : Auto, Did not fire
Focal Length : 4.1 mm
Subject Area : 1631 1223 1795 1077
Run Time Scale : 1000000000
Run Time Epoch : 0
Run Time Value : 20406467784125
Run Time Flags : Valid
Sub Sec Time Original : 918
Sub Sec Time Digitized : 918
Flashpix Version : 0100
Color Space : sRGB
Exif Image Width : 3264
Exif Image Height : 2448
Sensing Method : One-chip color area
Scene Type : Directly photographed
Exposure Mode : Auto
White Balance : Auto
Focal Length In 35mm Format : 33 mm
Scene Capture Type : Standard
Lens Info : 4.12mm f/2.4
Lens Make : Apple
Lens Model : iPhone 5 back camera 4.12mm f/2.4
GPS Latitude Ref : North
GPS Longitude Ref : West
GPS Altitude Ref : Above Sea Level
GPS Time Stamp : 07:22:24.56
Compression : JPEG (old-style)
Thumbnail Offset : 1222
Thumbnail Length : 12195
Image Width : 3264
Image Height : 2448
Encoding Process : Baseline DCT, Huffman coding
Bits Per Sample : 8
Color Components : 3
Y Cb Cr Sub Sampling : YCbCr4:2:0 (2 2)
Aperture : 2.4
GPS Altitude : 33.4 m Above Sea Level
GPS Latitude : 51 deg 51' 3.47" N
GPS Longitude : 2 deg 12' 19.92" W
GPS Position : 51 deg 51' 3.47" N, 2 deg 12' 19.92" W
Image Size : 3264x2448
Megapixels : 8.0
Run Time Since Power Up : 5:40:06
Scale Factor To 35 mm Equivalent: 8.0
Shutter Speed : 1/120
Create Date : 2014:09:23 08:22:25.918
Date/Time Original : 2014:09:23 08:22:25.918
Thumbnail Image : (Binary data 12195 bytes, use -b option to extract)
Circle Of Confusion : 0.004 mm
Field Of View : 57.2 deg
Focal Length : 4.1 mm (35 mm equivalent: 33.0 mm)
Hyperfocal Distance : 1.89 m
Light Value : 10.1
Another option is exiv2 which is available from here and also has various library APIs available.
I have not used it and cannot endorse it, but there is also a Python interface to exiv2.
In case you wanted a hand on Python subprocesses, you do this sort of thing:
import subprocess
...
...
p = subprocess.Popen(['identify -verbose someImage.jpg'], stdout=subprocess.PIPE)
retcode = p.wait()
data = p.stdout.read()
These properties should be stored in Exif data.
In Python, see here for some code to read Exif data.
With Opencv we can able to read image type,width,height,Depth but we cant able to read other parameters related to ISo,ShutterSpeed,Brightness,Description and Date Modified,Created.
If you want to get that information you can get it using C#