/*
* trace a path to an item matching a given python value
*/
static int
find_path_to_item(btsort_pyobject *tree, PyObject *value, char first,
char find, bt_path_t *path, char *found) {
int i, index, cmp = 0;
bt_node_t *node = (bt_node_t *)(tree->root);
int (*bisector)(PyObject **, int, PyObject *);
bisector = first ? bisect_left : bisect_right;
if (find) *found = 0;
path->tree = tree;
for (i = 0; i <= tree->depth; ++i) {
if (i) node = ((bt_branch_t *)node)->children[index];
if ((index = bisector(node->values, node->filled, value)) < 0)
return index;
if (find && index < node->filled && (cmp = PyObject_RichCompareBool(
node->values[index - (first ? 0 : 1)], value, Py_EQ)) < 0)
return cmp;
path->lineage[i] = node;
path->indexes[i] = index;
if (cmp) {
*found = 1;
break;
}
}
path->depth = i;
return 0;
}
/*private*/
void
InteriorPointArea::addPolygon(const Geometry *geometry)
{
if (geometry->isEmpty()) return;
Coordinate intPt;
double width;
auto_ptr<LineString> bisector ( horizontalBisector(geometry) );
if ( bisector->getLength() == 0.0 ) {
width = 0;
intPt = bisector->getCoordinateN(0);
}
else {
auto_ptr<Geometry> intersections ( bisector->intersection(geometry) );
const Geometry *widestIntersection = widestGeometry(intersections.get());
const Envelope *env = widestIntersection->getEnvelopeInternal();
width=env->getWidth();
env->centre(intPt);
}
if (!foundInterior || width>maxWidth) {
interiorPoint = intPt;
maxWidth = width;
foundInterior=true;
}
}
bool
LinkedTriple::calculateVelocity(StationaryParticle* p, StationaryParticle* q, StationaryParticle* r, float& vx, float& vy)
{
CParticleF b = bisector(p->getP(), r->getP(), q->getP());
vx = b.m_X;
vy = b.m_Y;
return true;
}
static double calc_y(double f,double Delta,double toler)
{
double y1,y2;
y1 = pow(f/Delta,1.5);
y2 = bisector(f,toler,0,10000,YYY);
if (fabs((y1-y2)/(y1+y2)) > 100*toler)
fprintf(stderr,"Inconsistency computing y: y1 = %f, y2 = %f, using y1.\n",
y1,y2);
return y1;
}
/*
* trace a path to the appropriate leaf for insertion
*/
static int
find_path_to_leaf(btsort_pyobject *tree, PyObject *value, char first,
bt_path_t *path) {
int i, index;
bt_node_t *node = (bt_node_t *)(tree->root);
int (*bisector)(PyObject **, int, PyObject *);
bisector = first ? bisect_left : bisect_right;
path->tree = tree;
for (i = 0; i <= tree->depth; ++i) {
if (i) node = ((bt_branch_t *)node)->children[index];
if ((index = bisector(node->values, node->filled, value)) < 0)
return index;
path->lineage[i] = node;
path->indexes[i] = index;
}
path->depth = tree->depth;
return 0;
}
static double calc_fluidicity(double Delta, double tol)
{
return bisector(Delta, tol, 0, 1, FD);
}
bool generateLinearSeparation(std::vector<point>& inputPoints,
double& a,
double& b,
double& c,
int& nBad1,
int& nBad2,
point& centroidOne,
point& centroidTwo)
{
int numOne=0, numTwo=0;
for (std::vector<point>::iterator pt = inputPoints.begin(); pt != inputPoints.end(); pt++)
{
if (pt->isClassOne)
{
numOne++;
centroidOne.x += pt->x;
centroidOne.y += pt->y;
}
else
{
numTwo++;
centroidTwo.x += pt->x;
centroidTwo.y += pt->y;
}
}
centroidOne.x /= numOne;
centroidOne.y /= numOne;
centroidTwo.x /= numTwo;
centroidTwo.y /= numTwo;
outputPoint(centroidOne);
outputPoint(centroidTwo);
point midpt(
(centroidTwo.x+centroidOne.x)/2,
(centroidTwo.y+centroidOne.y)/2);
outputPoint(midpt);
//direction vector
point oneToTwo(
centroidTwo.x-centroidOne.x,
centroidTwo.y-centroidOne.y);
double mag = distance(oneToTwo,point(0,0,false));
std::cerr << mag << std::endl;
oneToTwo.x /= mag;
oneToTwo.y /= mag;
//actual direction
point bisector(oneToTwo.x,oneToTwo.y);
outputPoint(bisector);
b = bisector.y;
a = bisector.x;
c = -(a*midpt.x+b*midpt.y);
for (std::vector<point>::iterator pt = inputPoints.begin(); pt != inputPoints.end(); pt++)
{
if(pt->isClassOne)
{
if(SGN(a*pt->x+b*pt->y+c) != SGN(a*centroidOne.x+b*centroidOne.y+c))
nBad1++;
}
else
{
if(SGN(a*pt->x+b*pt->y+c) != SGN(a*centroidTwo.x+b*centroidTwo.y+c))
nBad2++;
}
}
return true;
}
//=====================================================================================================//
void Trazados_Bisectriz_Intersecta(T_PilaDatos &Img_Buffer,SDL_Renderer* Render){
//OBJETIVO: Comprueba las posiciones de los puntos de las rectas en función del eje X, y realiza los trazados ajustados a estos
//ENTRADA: Un puntero Render, de tipo SDL Renderer y un Img_Buffer, de tipo T_PilaDatos donde se encuentran almacenados los valores
//PosCD: El Img_Buffer no debe haber sido modificado
T_Coords R1;
T_Coords R2;
T_Coords R3;
T_Coords R4;
Point Aux_1;
Point Aux_2;
Point Aux_3;
Point Aux_4;
Point Aux_5;
Point Aux_Bis;
Point Aux_Bis2;
double Pendiente;
int aux_Finder = 0; //Buscador de la posición de los datos de Img_Buffer
//Encontramos los datos insertados en la Pila
aux_Finder = Img_Buffer.Buscar_Estado(second_Point_OP1);
R1 = Img_Buffer.Buscar_Dato(aux_Finder).get_Coords();
aux_Finder = Img_Buffer.Buscar_Estado(second_Point_OP2);
R2 = Img_Buffer.Buscar_Dato(aux_Finder).get_Coords();
aux_Finder = Img_Buffer.Buscar_Estado(second_Point_OP3);
R3 = Img_Buffer.Buscar_Dato(aux_Finder).get_Coords();
aux_Finder = Img_Buffer.Buscar_Estado(second_Point_OP4);
R4 = Img_Buffer.Buscar_Dato(aux_Finder).get_Coords();
T_Recta RctAux_1(R1,R2);
T_Recta RctAux_2(R3,R4);
Aux_Bis = intersecta(RctAux_1,RctAux_2);
if (R3.get_xPos() > R4.get_xPos()){ //si el mayor es el punto 3
Aux_1 = Coords_ToPoint(R3);
Aux_2 = Coords_ToPoint(R4);
} else if (R3.get_xPos() < R4.get_xPos()){ //si el mayor es el punto 4
Aux_1 = Coords_ToPoint(R4);
Aux_2 = Coords_ToPoint(R3);
}
if(R1.get_xPos() < R2.get_xPos()){ //si el mayor es el punto 2
Aux_5 = Coords_ToPoint(R1);
Aux_3 = Coords_ToPoint(R2);
} else if (R1.get_xPos() > R2.get_xPos()){ //si el mayor es el punto 1
Aux_3 = Coords_ToPoint(R1);
Aux_5 = Coords_ToPoint(R2);
}
if (Aux_3.x > Aux_1.x){ //si el punto mayor de Recta1 esta mas alejado que el mayor de Recta2
Aux_4.x = Aux_1.x + 2*(Aux_3.x - Aux_1.x);
Pendiente = ((Aux_1.y - Aux_2.y)/(Aux_1.x - Aux_2.x));
Aux_4.y = (Pendiente* (Aux_4.x - Aux_1.x))+ Aux_1.y;
SDL_SetRenderDrawColor(Render,202, 18, 202,255);
Draw_Aspa(Render,Point_ToCoords(Aux_4)); //dibuja el nuevo punto convertido
SDL_SetRenderDrawColor(Render,34, 236, 226,255);
SDL_RenderDrawLine(Render,Aux_1.x,Aux_1.y,Aux_4.x,Aux_4.y);
} else { //El mayor de Recta2 es mayor que el de la Recta1
Aux_4 = Aux_1;
}
SDL_SetRenderDrawColor(Render,34, 236, 226,255);
SDL_RenderDrawLine(Render,Aux_3.x,Aux_3.y,Aux_Bis.x,Aux_Bis.y); //la recta prolongada desde el mayor de Recta1
SDL_RenderDrawLine(Render,Aux_1.x,Aux_1.y,Aux_Bis.x,Aux_Bis.y); //la recta prolongada desde el mayor de Recta2
Aux_Bis2 = bisector(Aux_5,Aux_Bis,Aux_4); //calcula el punto del bisector
SDL_SetRenderDrawColor(Render,0,255,0,255);
SDL_RenderDrawLine(Render,Aux_Bis.x,Aux_Bis.y,Aux_Bis2.x,Aux_Bis2.y); //dibuja la bisectriz
}
bool Operate_Second_Point(std::vector<T_ToolbarButton> Botones,T_Calculo &Calcs_Traz,SDL_Renderer *render,T_PilaDatos &Image_Buffer,const int &MAX_HEIGHT,std::string Path_s,SDL_Texture* Radio_o,SDL_Texture* Toolb_o,SDL_Rect &Src,SDL_Rect &Dst){
/*OBJETIVO: Realiza los trazados y operaciones del calculo del Cuerpo Mandibular
//ENTRADA: Un puntero al Renderer asociado a la ventana (render) de tipo SDL_Renderer, y una Pila de coordenadas(Image_Buffer) de tipo T_PilaDatos
//SALIDA: un booleano, que comprueba la realizacion correcta de los trazados en función de los datos de la Pila
//PreCD: Las operaciones de Operate_First_Point() deben haber sido realizadas
//PosCD: No se puede volver a realizar Operate_First_Point() o Operate_Second_Point() sin deshacer los trazos
*/
SDL_Event Ms_e;
bool endPointOps = false;
bool Aux_Bool = false;
long double CalC2 = 0;
int click_times_flag = 0;
T_Coords Aux_Click_Coords;
T_Coords Point_R1;
T_Coords Point_R2;
T_Coords Point_R3;
T_Coords Point_R4;
T_Coords Point_Calculate;
T_Coords Point_Calculate_2;
int codigo_comprobacion;
Point P_Aux1;
Point P_Aux2;
Point P_Aux3;
Point P_Aux4;
Point P_Aux5;
double Pendiente;
Point P_AuxBis;
Point P_AuxBis2;
T_Recta Rct_1(Point_R1,Point_R2);
T_Recta Rct_2(Point_R1,Point_R2);
T_Dato Aux_Saver;
while(!endPointOps){
Aux_Bool = false;
Aux_Click_Coords.set_xPos(0); //se resetea la x de la auxiliar
Aux_Click_Coords.set_yPos(0); //se resetea la x de la auxiliar
while (SDL_PollEvent(&Ms_e)){
if (Ms_e.type == SDL_MOUSEBUTTONDOWN){
if (Ms_e.button.button == SDL_BUTTON_LEFT){
Aux_Click_Coords.set_xPos(Ms_e.button.x);
Aux_Click_Coords.set_yPos(Ms_e.button.y);
codigo_comprobacion = Clik_Boton(Botones,Aux_Click_Coords);
if (codigo_comprobacion == 10){
switch(click_times_flag){
case 0: //primer punto (primero recta1)
std::cout << "Primer Punto del Cuerpo Mandibular" << std::endl;
Point_R1.set_xPos(Ms_e.button.x);
Point_R1.set_yPos(Ms_e.button.y);
Aux_Saver.set_Coords(Point_R1.get_xPos(),Point_R1.get_yPos());
Aux_Saver.set_Estado(second_Point_OP1);
Aux_Bool = Image_Buffer.Insertar_Dato(Aux_Saver);
if (Aux_Bool == true){
SDL_SetRenderDrawColor(render,202, 18, 202,255);
Draw_Aspa(render,Point_R1);
P_Aux1 = Coords_ToPoint(Point_R1);
click_times_flag++;
}
break;
case 1: //segundo punto (segundo recta1)
std::cout << "Segundo Punto del Cuerpo Mandibular" << std::endl;
Point_R2.set_xPos(Ms_e.button.x);
Point_R2.set_yPos(Ms_e.button.y);
Aux_Saver.set_Coords(Point_R2.get_xPos(),Point_R2.get_yPos());
Aux_Saver.set_Estado(second_Point_OP2);
Aux_Bool = Image_Buffer.Insertar_Dato(Aux_Saver);
if (Aux_Bool == true){
SDL_SetRenderDrawColor(render,202, 18, 202,255);
Draw_Aspa(render,Point_R2);
SDL_SetRenderDrawColor(render,34, 236, 226,255);
SDL_RenderDrawLine(render,Point_R1.get_xPos(),Point_R1.get_yPos(),Point_R2.get_xPos(),Point_R2.get_yPos());
T_Recta RctAux_1(Point_R1,Point_R2);
Rct_1 = RctAux_1;
click_times_flag++;
}
break;
case 2: //tercer punto (primero de la recta2)
std::cout << "Tercero Punto del Cuerpo Mandibular" << std::endl;
Point_R3.set_xPos(Ms_e.button.x);
Point_R3.set_yPos(Ms_e.button.y);
Aux_Saver.set_Coords(Point_R3.get_xPos(),Point_R3.get_yPos());
Aux_Saver.set_Estado(second_Point_OP3);
Aux_Bool = Image_Buffer.Insertar_Dato(Aux_Saver);
if (Aux_Bool == true){
SDL_SetRenderDrawColor(render,202, 18, 202,255);
Draw_Aspa(render,Point_R3);
click_times_flag++;
}
break;
case 3: //cuarto punto (segundo recta2)
std::cout << "Cuarto Punto del Cuerpo Mandibular" << std::endl;
Point_R4.set_xPos(Ms_e.button.x);
Point_R4.set_yPos(Ms_e.button.y);
Aux_Saver.set_Coords(Point_R4.get_xPos(),Point_R4.get_yPos());
Aux_Saver.set_Estado(second_Point_OP4);
Aux_Bool = Image_Buffer.Insertar_Dato(Aux_Saver);
if (Aux_Bool == true){
SDL_SetRenderDrawColor(render,202, 18, 202,255);
Draw_Aspa(render,Point_R4);
SDL_SetRenderDrawColor(render,34, 236, 226,255);
SDL_RenderDrawLine(render,Point_R3.get_xPos(),Point_R3.get_yPos(),Point_R4.get_xPos(),Point_R4.get_yPos());
//Realizamos el trazado de la bisectriz mediante los calculos adecuados
T_Recta RctAux_2(Point_R3,Point_R4);
Rct_2 = RctAux_2;
//
P_AuxBis = intersecta(Rct_1,RctAux_2);
//Comprueba los calculos para realizar el bisector
if (Point_R3.get_xPos() > Point_R4.get_xPos()){ //si el mayor es el punto 3
P_Aux2 = Coords_ToPoint(Point_R3);
P_Aux5 = Coords_ToPoint(Point_R4);
} else if (Point_R3.get_xPos() < Point_R4.get_xPos()){ //si el mayor es el punto 4
P_Aux2 = Coords_ToPoint(Point_R4);
P_Aux5 = Coords_ToPoint(Point_R3);
}
if(Point_R1.get_xPos() < Point_R2.get_xPos()){ //si el mayor es el punto 2
P_Aux3 = Coords_ToPoint(Point_R2);
} else if (Point_R1.get_xPos() > Point_R2.get_xPos()){ //si el mayor es el punto 1
P_Aux3 = Coords_ToPoint(Point_R1);
}
if (P_Aux3.x > P_Aux2.x){ //si el punto mayor de Recta1 esta mas alejado que el mayor de Recta2
P_Aux4.x = P_Aux2.x + 2*(P_Aux3.x - P_Aux2.x);
std::cout << "Distancia entre P4 y P3: "<< P_Aux4.x << std::endl;
Pendiente = ((P_Aux2.y - P_Aux5.y)/(P_Aux2.x - P_Aux5.x));
P_Aux4.y = (Pendiente* (P_Aux4.x - P_Aux2.x))+ P_Aux2.y;
std::cout << "Punto y prolongado: " << P_Aux4.y << std::endl;
SDL_SetRenderDrawColor(render,202, 18, 202,255);
Draw_Aspa(render,Point_ToCoords(P_Aux4)); //dibuja el nuevo punto convertido
SDL_SetRenderDrawColor(render,34, 236, 226,255);
SDL_RenderDrawLine(render,P_Aux2.x,P_Aux2.y,P_Aux4.x,P_Aux4.y);
} else { //El mayor de Recta2 es mayor que el de la Recta1
P_Aux4 = P_Aux2;
}
SDL_SetRenderDrawColor(render,34, 236, 226,255);
SDL_RenderDrawLine(render,Point_R2.get_xPos(),Point_R2.get_yPos(),P_AuxBis.x,P_AuxBis.y); //la recta prolongada desde el mayor de Recta1
SDL_RenderDrawLine(render,P_Aux2.x,P_Aux2.y,P_AuxBis.x,P_AuxBis.y); //la recta prolongada desde el mayor de Recta2
P_AuxBis2 = bisector(P_Aux1,P_AuxBis,P_Aux4); //calcula el punto del bisector
SDL_SetRenderDrawColor(render,0,255,0,255);
SDL_RenderDrawLine(render,P_AuxBis.x,P_AuxBis.y,P_AuxBis2.x,P_AuxBis2.y); //dibuja la bisectriz
std::cout << "Posicion x intersecta: "<< P_AuxBis.x << std::endl;
std::cout << "Posicion y intersecta: "<< P_AuxBis.y << std::endl;
std::cout << "Posicion x bisectriz: " << P_AuxBis2.x << std::endl;
std::cout << "Posicion y bisectriz: " << P_AuxBis2.y << std::endl;
click_times_flag++;
}
break;
case 4: //Primer punto Calculo
std::cout << "Quinto Punto del Cuerpo Mandibular" << std::endl;
Point_Calculate.set_xPos(Ms_e.button.x);
Point_Calculate.set_yPos(Ms_e.button.y);
Aux_Saver.set_Coords(Point_Calculate.get_xPos(),Point_Calculate.get_yPos());
Aux_Saver.set_Estado(second_Point_OP5);
Aux_Bool = Image_Buffer.Insertar_Dato(Aux_Saver);
if (Aux_Bool == true){ //comprueba que se inserta
SDL_SetRenderDrawColor(render,202, 18, 202,255);
Draw_Aspa(render,Point_Calculate);
click_times_flag++;
}
break;
case 5: //Segundo punto Calculo
std::cout << "Sexto Punto del Cuerpo Mandibular" << std::endl;
Point_Calculate_2.set_xPos(Ms_e.button.x);
Point_Calculate_2.set_yPos(Ms_e.button.y);
Aux_Saver.set_Coords(Point_Calculate_2.get_xPos(),Point_Calculate_2.get_yPos());
Aux_Saver.set_Estado(second_Point_OP6);
Aux_Bool = Image_Buffer.Insertar_Dato(Aux_Saver);
if (Aux_Bool == true){
SDL_SetRenderDrawColor(render,202, 18, 202,255);
Draw_Aspa(render,Point_Calculate_2);
endPointOps = true;
click_times_flag++;
}
break;
}
} else if (codigo_comprobacion == 3){
Recuperar_Trazados(Image_Buffer,Calcs_Traz,render,MAX_HEIGHT,Path_s,Radio_o,Toolb_o,Src,Dst);
click_times_flag--;
}
}
}
SDL_RenderPresent(render);
}
}
CalC2 = distancia(Point_Calculate,Point_Calculate_2);
Calcs_Traz.Insertar_Calculo(CalC2);
//renderTexture(tex_medidaca2(CalC2,render),render,posicion2x,posicion2y,nullptr);
return endPointOps;
}
circle circum_circle(point a, point b, point c) {
point o = crosspointLL(bisector(a, b), bisector(a, c));
return circle(o, abs(a - o));
}
