Metal1() {
fileLeft = "/apps/workspaces/kiste_data/stereo/3/left.png";
fileRight = "/apps/workspaces/kiste_data/stereo/3/right.png";
imgLeft = ImageFactory::readPNG(fileLeft);
imgRight = ImageFactory::readPNG(fileRight);
MatchingSAD sad(imgLeft, imgRight, 15);
Matching matcher;
Point2i pl1(608,834); Point2i pr1(400,873); //pr1 = matcher.refine(sad, pl1, pr1);
Point2i pl2(357,485); Point2i pr2(292,470); //pr2 = matcher.refine(sad, pl2, pr2);
Point2i pl3(461,672); Point2i pr3(294,678); //pr3 = matcher.refine(sad, pl3, pr3);
Point2i pl4(524,507); Point2i pr4(410,523); //pr4 = matcher.refine(sad, pl4, pr4);
Point2i pl5(518,479); Point2i pr5(440,493); //pr5 = matcher.refine(sad, pl5, pr5);
Point2i pl6(586,405); Point2i pr6(476,431); //pr6 = matcher.refine(sad, pl6, pr6);
Point2i pl7(593,324); Point2i pr7(532,349); //pr7 = matcher.refine(sad, pl7, pr7);
Point2i pl8(673,366); Point2i pr8(596,405); //pr8 = matcher.refine(sad, pl8, pr8);
fm.addCorrespondence(pl1, pr1);
fm.addCorrespondence(pl2, pr2);
fm.addCorrespondence(pl3, pr3);
fm.addCorrespondence(pl4, pr4);
fm.addCorrespondence(pl5, pr5);
fm.addCorrespondence(pl6, pr6);
fm.addCorrespondence(pl7, pr7);
fm.addCorrespondence(pl8, pr8);
//fm.addCorrespondence(pl9, pr9);
fm.estimate();
}
House1() {
fileLeft = "/apps/workspaces/kiste_data/stereo/4/left.png";
fileRight = "/apps/workspaces/kiste_data/stereo/4/right.png";
imgLeft = ImageFactory::readPNG(fileLeft);
imgRight = ImageFactory::readPNG(fileRight);
MatchingSAD sad(imgLeft, imgRight, 15);
Matching matcher;
Point2i pl1(110,244); Point2i pr1(198,296); //pr1 = matcher.refine(sad, pl1, pr1);
Point2i pl2(273,242); Point2i pr2(309,249); //pr2 = matcher.refine(sad, pl2, pr2);
Point2i pl3(88,117); Point2i pr3(129,121); //pr3 = matcher.refine(sad, pl3, pr3);
Point2i pl4(247,122); Point2i pr4(244,89); //pr4 = matcher.refine(sad, pl4, pr4);
Point2i pl5(321,100); Point2i pr5(320,50); //pr5 = matcher.refine(sad, pl5, pr5);
Point2i pl6(398,162); Point2i pr6(428,125); //pr6 = matcher.refine(sad, pl6, pr6);
Point2i pl7(393,282); Point2i pr7(424,273); //pr7 = matcher.refine(sad, pl7, pr7);
Point2i pl8(266,154); Point2i pr8(278,132); //pr8 = matcher.refine(sad, pl8, pr8);
fm.addCorrespondence(pl1, pr1);
fm.addCorrespondence(pl2, pr2);
fm.addCorrespondence(pl3, pr3);
fm.addCorrespondence(pl4, pr4);
fm.addCorrespondence(pl5, pr5);
fm.addCorrespondence(pl6, pr6);
fm.addCorrespondence(pl7, pr7);
fm.addCorrespondence(pl8, pr8);
//fm.addCorrespondence(pl9, pr9);
fm.estimate();
}
void IISource::get(Term& x) {
#if 1
x.setToOne();
int type = getType();
if(type==GBInputNumbers::s_IOFUNCTION) {
pair<bool,Alias<ISource> > pr(queryNamedFunction("Times"));
if(pr.first) {
pr.second.access().get(x.Coefficient());
pr.second.access().get(x.MonomialPart());
} else {
pair<bool,Alias<ISource> > pr2(queryNamedFunction("Rational"));
if(pr2.first) {
pr2.second.access().get(x.Coefficient());
} else {
get(x.MonomialPart());
};
};
} else if(type==GBInputNumbers::s_IOINTEGER) {
get(x.Coefficient());
} else {
get(x.MonomialPart());
};
#else
DBG();
#endif
};
IDIS() {
fileLeft = "/apps/workspaces/kiste_data/stereo/2/left.png";
fileRight = "/apps/workspaces/kiste_data/stereo/2/right.png";
imgLeft = ImageFactory::readPNG(fileLeft);
imgRight = ImageFactory::readPNG(fileRight);
MatchingSAD sad(imgLeft, imgRight, 15);
Matching matcher;
Point2i pl1(257,369); Point2i pr1(98,367); pr1 = matcher.refine(sad, pl1, pr1);
Point2i pl2(261,579); Point2i pr2(101,589); pr2 = matcher.refine(sad, pl2, pr2);
Point2i pl3(282,692); Point2i pr3(121,708); pr3 = matcher.refine(sad, pl3, pr3);
Point2i pl4(657,673); Point2i pr4(520,678); pr4 = matcher.refine(sad, pl4, pr4);
Point2i pl5(704,247); Point2i pr5(569,247); pr5 = matcher.refine(sad, pl5, pr5);
Point2i pl6(816,641); Point2i pr6(679,641); pr6 = matcher.refine(sad, pl6, pr6);
Point2i pl7(1113,503); Point2i pr7(964,501); pr7 = matcher.refine(sad, pl7, pr7);
Point2i pl8(1025,472); Point2i pr8(882,472); pr8 = matcher.refine(sad, pl8, pr8);
Point2i pl9(1096,345); Point2i pr9(948,348); pr9 = matcher.refine(sad, pl9, pr9);
fm.addCorrespondence(pl1, pr1);
fm.addCorrespondence(pl2, pr2);
fm.addCorrespondence(pl3, pr3);
fm.addCorrespondence(pl4, pr4);
fm.addCorrespondence(pl5, pr5);
fm.addCorrespondence(pl6, pr6);
fm.addCorrespondence(pl7, pr7);
fm.addCorrespondence(pl8, pr8);
//fm.addCorrespondence(pl9, pr9);
fm.estimate();
}
bool egcd(const bigint &b1, const bigint &b2, bigint &dr, bigint &r1, bigint &r2) const {
bool scs;
bigint dd(0), ppr1(0), ppr2(0), pr1(0), pr2(0), q, r(0), tr1(0), tr2(0);
if(compare(b1, b2) > 0) {
dd = b1;
dr = b2;
pr1 = one;
pr2.init();
} else {
dd = b2;
dr = b1;
pr1.init();
pr2 = one;
}
r1 = pr2;
r2 = pr1;
while((scs = divide(dd, dr, q, r)) && r.capacity() > 0) {
ppr1 = pr1;
ppr2 = pr2;
pr1 = r1;
pr2 = r2;
tr1.init();
tr2.init();
if(!(scs = (signedmultiply(q, pr1, tr1) && signedsubtract(ppr1, tr1, r1) &&
signedmultiply(q, pr2, tr2) && signedsubtract(ppr2, tr2, r2)))) {
break;
}
dd = dr;
dr = r;
q.init();
r.init();
}
return scs;
}
House3D() {
fileLeft = "/apps/workspaces/kiste_data/stereo/5/left.png";
fileRight = "/apps/workspaces/kiste_data/stereo/5/right.png";
imgLeft = ImageFactory::readPNG(fileLeft);
imgRight = ImageFactory::readPNG(fileRight);
// imgLeft = Derivative::getX(imgLeft);
// imgRight = Derivative::getX(imgRight);
// Normalize::inplace(imgLeft);
// Normalize::inplace(imgRight);
MatchingSAD sad(imgLeft, imgRight, 15);
Matching matcher;
Point2i pl1(245,381); Point2i pr1(176,366); //pr1 = matcher.refine(sad, pl1, pr1); // h1 lower left
Point2i pl2(308,323); Point2i pr2(312,323); //pr2 = matcher.refine(sad, pl2, pr2); // h1 lower right
Point2i pl3(222,82); Point2i pr3(246,82); //pr3 = matcher.refine(sad, pl3, pr3); // h1 upper right
Point2i pl4(134,76); Point2i pr4(101,78); //pr4 = matcher.refine(sad, pl4, pr4); // h1 upper left
Point2i pl5(501,218); Point2i pr5(416,228); //pr5 = matcher.refine(sad, pl5, pr5); // h1 mid left
Point2i pl6(620,201); Point2i pr6(625,219); //pr6 = matcher.refine(sad, pl6, pr6); // h1 mid right
Point2i pl7(546,83); Point2i pr7(570,78); //pr7 = matcher.refine(sad, pl7, pr7); // h1 upper right
Point2i pl8(423,79); Point2i pr8(378,77); //pr8 = matcher.refine(sad, pl8, pr8); // h1 upper left
Point2i pl9(381,413); Point2i pr9(319,420); //pr8 = matcher.refine(sad, pl8, pr8); // cube1a
Point2i plA(153,322); Point2i prA(68,299); //pr8 = matcher.refine(sad, pl8, pr8); // cube2
Point2i plB(348,361); Point2i prB(294,362); //pr8 = matcher.refine(sad, pl8, pr8); // cube1b
// Point2i pl1(242,219); Point2i pr1(171,212); //pr1 = matcher.refine(sad, pl1, pr1); // h1 lower left
// Point2i pl2(307,194); Point2i pr2(311,194); //pr2 = matcher.refine(sad, pl2, pr2); // h1 lower right
// Point2i pl3(222,82); Point2i pr3(246,82); //pr3 = matcher.refine(sad, pl3, pr3); // h1 upper right
// Point2i pl4(134,76); Point2i pr4(101,78); //pr4 = matcher.refine(sad, pl4, pr4); // h1 upper left
// Point2i pl5(501,218); Point2i pr5(416,228); //pr5 = matcher.refine(sad, pl5, pr5); // h1 lower left
// Point2i pl6(620,201); Point2i pr6(625,219); //pr6 = matcher.refine(sad, pl6, pr6); // h1 lower right
// Point2i pl7(546,83); Point2i pr7(570,78); //pr7 = matcher.refine(sad, pl7, pr7); // h1 upper right
// Point2i pl8(423,79); Point2i pr8(378,77); //pr8 = matcher.refine(sad, pl8, pr8); // h1 upper left
fm.addCorrespondence(pl1, pr1);
fm.addCorrespondence(pl2, pr2);
fm.addCorrespondence(pl3, pr3);
fm.addCorrespondence(pl4, pr4);
fm.addCorrespondence(pl5, pr5);
fm.addCorrespondence(pl6, pr6);
fm.addCorrespondence(pl7, pr7);
fm.addCorrespondence(pl8, pr8);
fm.addCorrespondence(pl9, pr9);
fm.addCorrespondence(plA, prA);
fm.addCorrespondence(plB, prB);
fm.estimate();
}
bool
State::add(EventBase *eb)
{
std::pair<size_t, EventBase *> pr(eb->id(),eb);
bool res = _map_by_id.insert(pr).second;
if(res) {
std::pair<time_t,EventBase *> pr2(eb->expiry(),eb);
_map_by_time.insert(pr2);
}
return res;
}
static void test2(char const *ex) {
smt_params params;
params.m_model = true;
ast_manager m;
reg_decl_plugins(m);
arith_util a(m);
expr_ref fml = parse_fml(m, ex);
app_ref_vector vars(m);
expr_ref_vector lits(m);
vars.push_back(m.mk_const(symbol("x"), a.mk_real()));
vars.push_back(m.mk_const(symbol("y"), a.mk_real()));
vars.push_back(m.mk_const(symbol("z"), a.mk_real()));
flatten_and(fml, lits);
smt::context ctx(m, params);
ctx.push();
ctx.assert_expr(fml);
lbool result = ctx.check();
VERIFY(result == l_true);
ref<model> md;
ctx.get_model(md);
ctx.pop(1);
std::cout << mk_pp(fml, m) << "\n";
expr_ref pr1(m), pr2(m), fml2(m);
expr_ref_vector bound(m);
ptr_vector<sort> sorts;
svector<symbol> names;
for (unsigned i = 0; i < vars.size(); ++i) {
bound.push_back(vars[i].get());
names.push_back(vars[i]->get_decl()->get_name());
sorts.push_back(m.get_sort(vars[i].get()));
}
expr_abstract(m, 0, bound.size(), bound.c_ptr(), fml, fml2);
fml2 = m.mk_exists(bound.size(), sorts.c_ptr(), names.c_ptr(), fml2);
qe::expr_quant_elim qe(m, params);
for (unsigned i = 0; i < vars.size(); ++i) {
VERIFY(qe::arith_project(*md, vars[i].get(), lits));
}
pr1 = mk_and(lits);
qe(m.mk_true(), fml2, pr2);
std::cout << mk_pp(pr1, m) << "\n";
std::cout << mk_pp(pr2, m) << "\n";
expr_ref npr2(m);
npr2 = m.mk_not(pr2);
ctx.push();
ctx.assert_expr(pr1);
ctx.assert_expr(npr2);
VERIFY(l_false == ctx.check());
ctx.pop(1);
}
bool
is_indel_conflict(const indel_key& ik1,
const indel_key& ik2) {
// add one to the end_pos of all indels to prevent immediately
// adjacent indels in the final alignments:
pos_range pr1(ik1.open_pos_range());
pr1.end_pos++;
pos_range pr2(ik2.open_pos_range());
pr2.end_pos++;
return pr1.is_range_intersect(pr2);
}
Garden() {
fileLeft = getDataFile("stereo1.jpg"); // left image
fileRight = getDataFile("stereo2.jpg"); // right image
imgLeft = ImageFactory::readJPEG(fileLeft);
imgRight = ImageFactory::readJPEG(fileRight);
MatchingSAD sad(imgLeft, imgRight, 15);
Matching matcher;
// image1 // image2 (left of image1) // refine the approximate matching positions
Point2i pl1(85,53); Point2i pr1(29,57); pr1 = matcher.refine(sad, pl1, pr1);
Point2i pl2(264,34); Point2i pr2(209,36); pr2 = matcher.refine(sad, pl2, pr2);
Point2i pl3(362,32); Point2i pr3(306,32); pr3 = matcher.refine(sad, pl3, pr3);
Point2i pl4(213,155); Point2i pr4(155,159); pr4 = matcher.refine(sad, pl4, pr4);
Point2i pl5(96,209); Point2i pr5(36,210); pr5 = matcher.refine(sad, pl5, pr5);
Point2i pl6(330,212); Point2i pr6(269,211); pr6 = matcher.refine(sad, pl6, pr6);
Point2i pl7(276,241); Point2i pr7(216,242); pr7 = matcher.refine(sad, pl7, pr7);
Point2i pl8(385,332); Point2i pr8(321,328); pr8 = matcher.refine(sad, pl8, pr8);
Point2i pl9(180,389); Point2i pr9(114,388); pr9 = matcher.refine(sad, pl9, pr9);
Point2i pl10(136,500); Point2i pr10(67,500); pr10 = matcher.refine(sad, pl10, pr10);
fm.addCorrespondence(pl1, pr1);
fm.addCorrespondence(pl2, pr2);
fm.addCorrespondence(pl3, pr3);
fm.addCorrespondence(pl4, pr4);
fm.addCorrespondence(pl5, pr5);
fm.addCorrespondence(pl6, pr6);
fm.addCorrespondence(pl7, pr7);
fm.addCorrespondence(pl8, pr8);
// fm.addCorrespondence(pl9, pr9);
// fm.addCorrespondence(pl10, pr10);
fm.estimate();
}
static int value_set(struct bt_ctf_field_type *type,
struct bt_ctf_event *event,
const char *name, u64 val)
{
struct bt_ctf_field *field;
bool sign = bt_ctf_field_type_integer_get_signed(type);
int ret;
field = bt_ctf_field_create(type);
if (!field) {
pr_err("failed to create a field %s\n", name);
return -1;
}
if (sign) {
ret = bt_ctf_field_signed_integer_set_value(field, val);
if (ret) {
pr_err("failed to set field value %s\n", name);
goto err;
}
} else {
ret = bt_ctf_field_unsigned_integer_set_value(field, val);
if (ret) {
pr_err("failed to set field value %s\n", name);
goto err;
}
}
ret = bt_ctf_event_set_payload(event, name, field);
if (ret) {
pr_err("failed to set payload %s\n", name);
goto err;
}
pr2(" SET [%s = %" PRIu64 "]\n", name, val);
err:
bt_ctf_field_put(field);
return ret;
}
int main(int argc, const char** argv) {
std::unique_ptr<Shape> pr1(new Rectangle);
std::unique_ptr<Shape> pr2(new Rectangle);
std::unique_ptr<Shape> pe1(new Ellipse);
std::unique_ptr<Shape> pe2(new Ellipse);
std::unique_ptr<Shape> pt(new Triangle);
std::cout << "Dynamic type dispatch\n";
LOG(pr1->Intersect(pe1.get()));
LOG(pe1->Intersect(pr1.get()));
LOG(pr1->Intersect(pr2.get()));
// Here the dispatch is routed to Shape, since Ellipse doesn't define
// intersections with ellipses.
LOG(pe1->Intersect(pe2.get()));
// Since Rectangle and Triangle don't define intersection ops with each other,
// these calls are routed to Shape.
LOG(pr1->Intersect(pt.get()));
LOG(pt->Intersect(pr1.get()));
return 0;
}
Malla* GeneraFromArchivosXYZU::aplicar() {
int n_triangulos = 0, n_cuadrilateros = 0; // cantidad de caras de tres y cuatro lados
//Lineas necesarias para que scanf lea archivo en computadores seteados en otro lenguaje.
setlocale(LC_NUMERIC, "POSIX");
FILE *arch_x = fopen(archivo_x.c_str(),"r");
FILE *arch_y = fopen(archivo_y.c_str(),"r");
FILE *arch_z = fopen(archivo_z.c_str(),"r");
FILE *arch_u = fopen(archivo_u.c_str(),"r");
char line[50];
char cx[16];
char cy[16];
char cz[16];
int num_puntos, num_caras;
float x,y,z,nx,ny,nz,u;
fscanf(arch_x,"%s %s\n",line,line);
fscanf(arch_y,"%s %s\n",line,line);
fscanf(arch_z,"%s %s\n",line,line);
fscanf(arch_u,"%s %s\n",line,line);
num_puntos=0;
Nodos *nodos = new Nodos();
Nodo *nodo;
while(true) {
fscanf(arch_x,"%s %s %s\n",cx,cy,cz);
fscanf(arch_y,"%s %s %s\n",cx,cy,cz);
fscanf(arch_z,"%s %s %s\n",cx,cy,cz);
fscanf(arch_u,"%s %s %s\n",cx,cy,cz);
if(strcmp(cx,"%") == 0) {
break;
}
sscanf(cx,"%f",&x);
sscanf(cy,"%f",&y);
sscanf(cz,"%f",&z);
nodo = new Nodo(Punto(x,y,z));
nodos->addNodo(nodo);
num_puntos++;
}
map<pair<int,int>,int> ind_arcos;
map<pair<int,int>,int>::iterator iter1;
map<pair<int,int>,int>::iterator iter2;
vector<int> indice_puntos;
vector<int> indice_arcos;
Arcos *arcos = new Arcos();
Caras *caras = new Caras();
Cara *c;
int indice;
char *token;
int indices[4];
int n_lados;
num_caras=0;
while(true) {
fgets(line, 50, arch_x);
fgets(line, 50, arch_y);
fgets(line, 50, arch_z);
fgets(line, 50, arch_u);
if(strpbrk("%",line) != NULL) {
break;
}
token = strtok(line," ");
for(int i=0; i<3; ++i) {
sscanf(token,"%d",&indices[i]);
token = strtok(NULL, " ");
}
if(token == NULL) { // Caso triángulos
n_triangulos++;
n_lados = 3;
}
else { // Caso cuadriláteros
sscanf(token,"%d",&indices[3]);
n_cuadrilateros++;
n_lados = 4;
}
//Nota: Por bug en los archivos de entrada, debo invertir el orden para que las normales queden bien.
//for(int i=n_lados-1; i>=0; --i) // invertido por bug archivo entrada
for(int i=0; i<n_lados; ++i) // así debiera ser
indice_puntos.push_back(indices[i]-1);
for(int j=0; j<n_lados; j++) {
int ind1 = indice_puntos[j];
int ind2 = indice_puntos[int(fmod(j+1,n_lados))];
pair<int,int> pr1(ind1,ind2);
pair<int,int> pr2(ind2,ind1);
iter1 = ind_arcos.find(pr1);
iter2 = ind_arcos.find(pr2);
if(iter1 != ind_arcos.end())
indice_arcos.push_back(iter1->second);
else if(iter2 != ind_arcos.end())
indice_arcos.push_back(iter2->second);
else {
indice = arcos->addArco(new Arco(ind1,ind2));
indice_arcos.push_back(indice);
ind_arcos.insert(make_pair(pr1,indice));
nodos->addArcoNodo(ind1,indice);
nodos->addArcoNodo(ind2,indice);
}
}
if(n_lados == 3)
c = new Triangulo(indice_puntos,indice_arcos);
else // n_lados == 4
c = new Cuadrilatero(indice_puntos,indice_arcos);
int ind_cara = caras->addCara(c);
num_caras++;
for(int j=0; j<n_lados; j++) {
arcos->setCaraArco(indice_arcos[j],ind_cara);
nodos->addCaraNodo(indice_puntos[j],ind_cara);
}
indice_puntos.clear();
indice_arcos.clear();
}
float max_concentracion = 0;
float min_concentracion = 999999999;
for(int i=0; i<num_puntos; i++) {
fscanf(arch_x,"%f\n",&nx);
fscanf(arch_y,"%f\n",&ny);
fscanf(arch_z,"%f\n",&nz);
fscanf(arch_u,"%f\n",&u);
if(u < min_concentracion) {
min_concentracion = u;
}
if(u > max_concentracion) {
max_concentracion = u;
}
Vect normal = Vect(nx,ny,nz);
nodos->getNodo(i)->setNormal(normal);
nodos->getNodo(i)->setConcentracion(u);
}
cout << "max_concentracion = " << max_concentracion << endl;
cout << "min_concentracion = " << min_concentracion << endl;
Malla *malla = 0;
if(n_cuadrilateros == 0)
malla = new MallaTriangulos(nodos,arcos,caras);
else if(n_triangulos == 0)
malla = new MallaCuadrilateros(nodos,arcos,caras);
else
malla = new Malla(nodos,arcos,caras);
malla->setConcentracionMax(max_concentracion);
malla->setConcentracionMin(min_concentracion);
fclose(arch_x);
fclose(arch_y);
fclose(arch_z);
fclose(arch_u);
setlocale(LC_NUMERIC, "");
//Chequeamos consistencia topologica.
int V=malla->getNumNodos();
int E=malla->getNumArcos();
int F=malla->getNumCaras();
cout << "Numero de nodos=" << V << endl;
cout << "Numero de arcos=" << E << endl;
cout << "Numero de caras=" << F << endl;
if (V-E+F==2 || V-E+F==0)
cout << "La malla es consistente. Cumple la formula de Euler: V-E+F=2" << endl;
else
cout << "Atencion, la malla no es consistente. No cumple la formula de Euler: V(" << V << ")-E(" << E << "+F("<< F << ")=" << V-E+F << " y deberia ser V-E+F=2" << endl;
assert(malla->checkMalla(true) >= 0);
return malla;
}
Malla* GeneraFromComsol_1::aplicar() {
int n_triangulos = 0, n_cuadrilateros = 0; // cantidad de caras de tres y cuatro lados
ifstream in(archivo.c_str());
char line[MAXLINE];
in.getline(line,MAXLINE);
string cx,cy,cz;
float x,y,z;
int num_puntos, num_caras;
num_puntos=0;
Nodos *nodos = new Nodos();
Nodo *nodo;
while(true) {
in.getline(line,MAXLINE);
stringstream streamin(line);
if (line[0]=='%')
break;
streamin >> x;
streamin >> y;
streamin >> z;
nodo = new Nodo(Punto(x,y,z));
nodos->addNodo(nodo);
num_puntos++;
}
map<pair<int,int>,int> ind_arcos;
map<pair<int,int>,int>::iterator iter1;
map<pair<int,int>,int>::iterator iter2;
vector<int> indice_puntos;
vector<int> indice_arcos;
Arcos *arcos = new Arcos();
Caras *caras = new Caras();
Cara *c;
int indice;
int indices[4], n_lados;
num_caras=0;
while(true) {
indices[3]=-1;
in.getline(line,MAXLINE);
if (in.fail() || line[0]=='%')
break;
stringstream streamin(line);
for(int i=0; i<4; i++)
streamin >> indices[i];
if(indices[3] == -1) {
n_triangulos++;
n_lados = 3;
}
else {
n_cuadrilateros++;
n_lados = 4;
}
//Nota: Por bug en los archivos de entrada, debo invertir el orden para que las normales queden bien.
//for(int i=n_lados-1; i>=0; i--) // por el bug
for(int i=0; i<n_lados; i++) // así debiera ser
indice_puntos.push_back(indices[i]-1);
for(int j=0; j<n_lados; j++) {
int ind1 = indice_puntos[j];
int ind2 = indice_puntos[int(fmod(j+1,n_lados))];
pair<int,int> pr1(ind1,ind2);
pair<int,int> pr2(ind2,ind1);
iter1 = ind_arcos.find(pr1);
iter2 = ind_arcos.find(pr2);
if(iter1 != ind_arcos.end())
indice_arcos.push_back(iter1->second);
else if(iter2 != ind_arcos.end())
indice_arcos.push_back(iter2->second);
else {
indice = arcos->addArco(new Arco(ind1,ind2));
indice_arcos.push_back(indice);
ind_arcos.insert(make_pair(pr1,indice));
nodos->addArcoNodo(ind1,indice);
nodos->addArcoNodo(ind2,indice);
}
}
if(n_lados == 3)
c = new Triangulo(indice_puntos,indice_arcos);
else if(n_lados == 4)
c = new Cuadrilatero(indice_puntos,indice_arcos);
else
c = new Cara(indice_puntos,indice_arcos);
int ind_cara = caras->addCara(c);
num_caras++;
for(int j=0; j<n_lados; j++) {
arcos->setCaraArco(indice_arcos[j],ind_cara);
nodos->addCaraNodo(indice_puntos[j],ind_cara);
}
indice_puntos.clear();
indice_arcos.clear();
}
Malla *malla = 0;
if(n_cuadrilateros == 0)
malla = new MallaTriangulos(nodos,arcos,caras);
else if(n_triangulos == 0)
malla = new MallaCuadrilateros(nodos,arcos,caras);
else
malla = new Malla(nodos,arcos,caras);
malla->setConcentracionTodos(1.0);
malla->setConcentracionMax(1.0);
malla->setConcentracionMin(0.0);
malla->setNormales();
in.close();
//Chequeamos consistencia topologica.
int V=malla->getNumNodos();
int E=malla->getNumArcos();
int F=malla->getNumCaras();
cout << "Numero de nodos=" << V << endl;
cout << "Numero de arcos=" << E << endl;
cout << "Numero de caras=" << F << endl;
if (V-E+F==2 || V-E+F==0)
cout << "La malla es consistente. Cumple la formula de Euler: V-E+F=2" << endl;
else
cout << "Atencion, la malla no es consistente. No cumple la formula de Euler: V-E+F=" << V-E+F << " y deberia ser V-E+F=2" << endl;
assert(malla->checkMalla(true) >= 0);
cout << endl;
return malla;
}
int main()
{
Prueba pr0;
mtk::Signal<> mySignal;
std::cout << std::endl << "una conexión a uno Tres conexiones a 2, mandamos un signal" << std::endl;
mySignal.connect(&pr0, &Prueba::Recibio);
mySignal.connect(&pr0, &Prueba::Recibio2);
mySignal.connect(&pr0, &Prueba::Recibio2);
mySignal.connect(&pr0, &Prueba::Recibio2);
mySignal.emit();
std::cout << std::endl << "Desconectamos un 2" << std::endl;
bool result = mySignal.disconnect(&pr0, &Prueba::Recibio2);
if (result)
std::cout << std::endl << "Desconectamos un 2 OK" << std::endl;
else
std::cout << std::endl << "Desconectamos un 2 FAIL" << std::endl;
mySignal.emit();
std::cout << std::endl << "Desconectamos un 1" << std::endl;
result = mySignal.disconnect(&pr0, &Prueba::Recibio);
if (result)
std::cout << std::endl << "Desconectamos un 1 OK" << std::endl;
else
std::cout << std::endl << "Desconectamos un 1 FAIL" << std::endl;
mySignal.emit();
std::cout << std::endl << "Desconectamos un 1" << std::endl;
result = mySignal.disconnect(&pr0, &Prueba::Recibio);
if (result)
std::cout << std::endl << "Desconectamos un 1 OK" << std::endl;
else
std::cout << std::endl << "Desconectamos un 1 FAIL" << std::endl;
mySignal();
std::cout << std::endl << "desconectamos todo... y mandamos un mensaje nuevo";
mySignal.disconnect_all();
mySignal();
// pendiente la copia de signal
// falta meter el countPtr
// Signal<> mySignal2;
// mySignal2 = mySignal;
// pendiente que se desconecte cuando el receptor salga de ámbito
// delicado
Prueba pr6(22);
mySignal.connect(&pr6, &Prueba::Recibio);
std::cout << std::endl << "Creamos otro recpetor temporal, conectamos a 1 mandamo señal";
{
Prueba pr1(23);
mySignal.connect(&pr1, &Prueba::Recibio);
mySignal();
}
std::cout << std::endl << "el últmo receptor temporal sale de ámbito";
Prueba pr2(24);
mySignal.connect(&pr2, &Prueba::Recibio);
std::cout << std::endl << "acceso incorrecto a la memoria";
std::cout << std::endl << "Sólo se debería escribir 1";
mySignal();
//mtk::Signal<> mySignal;
//std::cout << std::endl << "Creamos un temporal 777 que sale de ámbito antes de poner mandar nada";
{
Prueba pr1(77);
mySignal.connect(&pr1, &Prueba::Recibio);
mySignal.connect(&pr1, &Prueba::Recibio);
mySignal.emit();
}
Prueba pr22(88);
mySignal.connect(&pr22, &Prueba::Recibio);
mySignal();
mySignal.disconnect(&pr22, &Prueba::Recibio);
mySignal();
Prueba2 prueba2;
prueba2.Connect();
prueba2.Signal();
{
// conectamos dos signal al mismo receptor
// sacamos de ámbito a dicho receptor
// mandamos una signal
// tiene que recibirse
// esto generaba un error antes del 5 de julio de 2010
Prueba pr;
mtk::Signal<> signalpr1;
mtk::Signal<> signalpr2;
signalpr1.connect(&pr, &Prueba::Recibio);
signalpr2.connect(&pr, &Prueba::Recibio);
signalpr1.disconnect(&pr, &Prueba::Recibio);
std::cout << "SE TIENE QUE RECIBIR..." << std::endl;
signalpr2.emit();
}
return 0;
}
