int main(int argc, char** argv) {
Image* img = I_new(640, 480);
I_fill(img, C_new(0, 0, 0));
I_changeColor(img, C_new(255, 255, 255));
// Try horizontal lines, from left to right and right to left
draw_line_bresenham(img, 100, 100, 200, 100);
draw_line_bresenham(img, 200, 200, 100, 200);
for(int i = 100 ; i <= 200 ; ++i) {
assert(img->_buffer[i][100]._blue == 255);
assert(img->_buffer[i][100]._red == 255);
assert(img->_buffer[i][100]._green == 255);
assert(img->_buffer[i][200]._blue == 255);
assert(img->_buffer[i][200]._red == 255);
assert(img->_buffer[i][200]._green == 255);
}
// Try vertical lines, from top to bottom and bottom to top
draw_line_bresenham(img, 100, 100, 100, 200);
draw_line_bresenham(img, 200, 200, 200, 100);
for(int i = 100 ; i <= 200 ; ++i) {
assert(img->_buffer[100][i]._blue == 255);
assert(img->_buffer[100][i]._red == 255);
assert(img->_buffer[100][i]._green == 255);
assert(img->_buffer[200][i]._blue == 255);
assert(img->_buffer[200][i]._red == 255);
assert(img->_buffer[200][i]._green == 255);
}
}
int main(int argc, char **argv)
{
red = C_new(1.0, 0.0, 0.0);
green = C_new(0.0, 1.0, 0.0);
black = C_new(0.0, 0.0, 0.0);
white = C_new(1.0, 1.0, 1.0);
if((argc!=3)&&(argc!=2))
{
fprintf(stderr,"\n\nUsage \t: %s <width> <height>\nou",argv[0]);
fprintf(stderr,"\t: %s <ppmfilename> \n\n",argv[0]);
exit(1);
}
else
{
if(argc==2)
{
img = I_read(argv[1]);
largeur = img->_width;
hauteur = img->_height;
}
else
{
largeur = atoi(argv[1]);
hauteur = atoi(argv[2]);
img = I_new(largeur,hauteur);
//Color rouge = C_new(100,0,0);
//Color blanc = C_new(1.0, 1.0, 1.0);
//I_checker(img,rouge,blanc,50);
}
int windowPosX = 100, windowPosY = 100;
glutInitWindowSize(largeur,hauteur);
glutInitWindowPosition(windowPosX,windowPosY);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE );
glutInit(&argc, argv);
glutCreateWindow(argv[0]);
glViewport(0, 0, largeur, hauteur);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glOrtho(0,largeur,0,hauteur,-1,1);
glutDisplayFunc(display_CB);
glutKeyboardFunc(keyboard_CB);
glutSpecialFunc(special_CB);
glutMouseFunc(mouse_CB);
// glutMotionFunc(mouse_move_CB);
// glutPassiveMotionFunc(passive_mouse_move_CB);
glutMainLoop();
return 0;
}
}
Image* I_read(char *imagefilename)
{
Image *img;
char command[100];
if(_isPpm(imagefilename)) sprintf(command,"cp %s input.ppm",imagefilename);
else sprintf(command,"convert %s input.ppm",imagefilename);
int stat = system(command);
if(stat!=0)
{
fprintf(stderr,"Convert : %s -> input.ppm impossible conversion.\n", imagefilename);
exit(1);
}
else
{
Ppm ppm = PPM_nouv("input.ppm", PPM_LECTURE);
system("rm input.ppm");
fprintf(stderr,"%d x %d\n",PPM_largeur(ppm),PPM_hauteur(ppm));
if(ppm!=NULL)
{
img = I_new(PPM_largeur(ppm),PPM_hauteur(ppm));
int nb_bits=ppm->_nb_bits;
int valmax = ppm->_valmax;
int nb_pixels = img->_width*img->_height;
if(nb_bits <= 8)
{
unsigned char *donnees = (unsigned char*)calloc(3*nb_pixels,sizeof(unsigned char));
PPM_lectureDonneesChar(ppm, donnees);
int x,y;
for(y=0;y<img->_height;y++)
for(x=0;x<img->_width;x++)
{
int indice = (img->_height-y)*img->_width + x;
Color c = C_new((1.0*donnees[3*indice ])/valmax,
(1.0*donnees[3*indice+1])/valmax,
(1.0*donnees[3*indice+2])/valmax);
_plot(img,x,y,c);
}
}
else
{
unsigned short *donnees = (unsigned short*)calloc(3*nb_pixels,sizeof(unsigned short));
PPM_lectureDonneesShort(ppm, donnees);
int x,y;
for(y=0;y<img->_height;y++)
for(x=0;x<img->_width;x++)
{
int indice = (img->_height-y)*img->_width + x;
Color c = C_new((1.0*donnees[3*indice ])/valmax,
(1.0*donnees[3*indice+1])/valmax,
(1.0*donnees[3*indice+2])/valmax);
img->_buffer[x][y] = c;
}
}
PPM_fermeture(ppm);
return(img);
}
else
return(NULL);
}
}
void Polyhedra::Initialize(){
if (init) return;
bool isRandom = false;
//get vertices
int N = (int) v.size();
if (N==0) {
//generate randomly
while ((int) v.size()<4) GenerateRandomGeometry();
N = (int) v.size();
isRandom = true;
}
//compute convex hull of vertices
std::vector<CGALpoint> points;
points.resize(v.size());
for(int i=0;i<N;i++) {
points[i] = CGALpoint(v[i][0],v[i][1],v[i][2]);
}
CGAL::convex_hull_3(points.begin(), points.end(), P);
//connect triagular facets if possible
std::transform(P.facets_begin(), P.facets_end(), P.planes_begin(),Plane_equation());
P = Simplify(P, 1E-9);
//modify order of v according to CGAl polyhedron
int i = 0;
v.clear();
for (Polyhedron::Vertex_iterator vIter = P.vertices_begin(); vIter != P.vertices_end(); ++vIter, i++){
v.push_back(Vector3r(vIter->point().x(),vIter->point().y(),vIter->point().z()));
}
//list surface triangles for plotting
faceTri.clear();
std::transform(P.facets_begin(), P.facets_end(), P.planes_begin(),Plane_equation());
for (Polyhedron::Facet_iterator fIter = P.facets_begin(); fIter != P.facets_end(); fIter++){
Polyhedron::Halfedge_around_facet_circulator hfc0;
int n = fIter->facet_degree();
hfc0 = fIter->facet_begin();
int a = std::distance(P.vertices_begin(), hfc0->vertex());
for (int i=2; i<n; i++){
++hfc0;
faceTri.push_back(a);
faceTri.push_back(std::distance(P.vertices_begin(), hfc0->vertex()));
faceTri.push_back(std::distance(P.vertices_begin(), hfc0->next()->vertex()));
}
}
//compute centroid and volume
P_volume_centroid(P, &volume, ¢roid);
//check vierd behavior of CGAL in tessalation
if(isRandom && volume*1.75<4./3.*3.14*size[0]/2.*size[1]/2.*size[2]/2.) {
v.clear();
seed = rand();
Initialize();
}
Vector3r translation((-1)*centroid);
//set centroid to be [0,0,0]
for(int i=0;i<N;i++) {
v[i] = v[i]-centroid;
}
if(isRandom) centroid = Vector3r::Zero();
Vector3r origin(0,0,0);
//move and rotate also the CGAL structure Polyhedron
Transformation t_trans(1.,0.,0.,translation[0],0.,1.,0.,translation[1],0.,0.,1.,translation[2],1.);
std::transform( P.points_begin(), P.points_end(), P.points_begin(), t_trans);
//compute inertia
Real vtet;
Vector3r ctet;
Matrix3r Itet1, Itet2;
Matrix3r inertia_tensor(Matrix3r::Zero());
for(int i=0; i<(int) faceTri.size(); i+=3){
vtet = std::abs((origin-v[faceTri[i+2]]).dot((v[faceTri[i]]-v[faceTri[i+2]]).cross(v[faceTri[i+1]]-v[faceTri[i+2]]))/6.);
ctet = (origin+v[faceTri[i]]+v[faceTri[i+1]]+v[faceTri[i+2]]) / 4.;
Itet1 = TetraInertiaTensor(origin-ctet, v[faceTri[i]]-ctet, v[faceTri[i+1]]-ctet, v[faceTri[i+2]]-ctet);
ctet = ctet-origin;
Itet2<<
ctet[1]*ctet[1]+ctet[2]*ctet[2], -ctet[0]*ctet[1], -ctet[0]*ctet[2],
-ctet[0]*ctet[1], ctet[0]*ctet[0]+ctet[2]*ctet[2], -ctet[2]*ctet[1],
-ctet[0]*ctet[2], -ctet[2]*ctet[1], ctet[1]*ctet[1]+ctet[0]*ctet[0];
inertia_tensor = inertia_tensor + Itet1 + Itet2*vtet;
}
if(std::abs(inertia_tensor(0,1))+std::abs(inertia_tensor(0,2))+std::abs(inertia_tensor(1,2)) < 1E-13){
// no need to rotate, inertia already diagonal
orientation = Quaternionr::Identity();
inertia = Vector3r(inertia_tensor(0,0),inertia_tensor(1,1),inertia_tensor(2,2));
}else{
// calculate eigenvectors of I
Vector3r rot;
Matrix3r I_rot(Matrix3r::Zero()), I_new(Matrix3r::Zero());
matrixEigenDecomposition(inertia_tensor,I_rot,I_new);
// I_rot = eigenvectors of inertia_tensors in columns
// I_new = eigenvalues on diagonal
// set positove direction of vectors - otherwise reloading does not work
Matrix3r sign(Matrix3r::Zero());
Real max_v_signed = I_rot(0,0);
Real max_v = std::abs(I_rot(0,0));
if (max_v < std::abs(I_rot(1,0))) {max_v_signed = I_rot(1,0); max_v = std::abs(I_rot(1,0));}
if (max_v < std::abs(I_rot(2,0))) {max_v_signed = I_rot(2,0); max_v = std::abs(I_rot(2,0));}
sign(0,0) = max_v_signed/max_v;
max_v_signed = I_rot(0,1);
max_v = std::abs(I_rot(0,1));
if (max_v < std::abs(I_rot(1,1))) {max_v_signed = I_rot(1,1); max_v = std::abs(I_rot(1,1));}
if (max_v < std::abs(I_rot(2,1))) {max_v_signed = I_rot(2,1); max_v = std::abs(I_rot(2,1));}
sign(1,1) = max_v_signed/max_v;
sign(2,2) = 1.;
I_rot = I_rot*sign;
// force the eigenvectors to be right-hand oriented
Vector3r third = (I_rot.col(0)).cross(I_rot.col(1));
I_rot(0,2) = third[0];
I_rot(1,2) = third[1];
I_rot(2,2) = third[2];
inertia = Vector3r(I_new(0,0),I_new(1,1),I_new(2,2));
orientation = Quaternionr(I_rot);
//rotate the voronoi cell so that x - is maximal inertia axis and z - is minimal inertia axis
//orientation.normalize(); //not needed
for(int i=0; i< (int) v.size();i++) {
v[i] = orientation.conjugate()*v[i];
}
//rotate also the CGAL structure Polyhedron
Matrix3r rot_mat = (orientation.conjugate()).toRotationMatrix();
Transformation t_rot(rot_mat(0,0),rot_mat(0,1),rot_mat(0,2),rot_mat(1,0),rot_mat(1,1),rot_mat(1,2),rot_mat(2,0),rot_mat(2,1),rot_mat(2,2),1.);
std::transform( P.points_begin(), P.points_end(), P.points_begin(), t_rot);
}
//initialization done
init = 1;
}
