bool KMeans::agruparPontos(vector<Ponto *> * pontos, vector<Ponto> centroides)
{
bool mudanca = false;
for (size_t indice_ponto = 0; indice_ponto < pontos->size(); indice_ponto++)
{
Ponto * ponto = pontos->at(indice_ponto);
float menor_distancia = std::numeric_limits<float>::max();
int melhor_cluster = -1;
for (int cluster = 0; cluster < _k; cluster++)
{
Ponto * centroide = ¢roides.at(cluster);
float distancia_centroide = _distancia.distancia(ponto, centroide);
if (distancia_centroide < menor_distancia)
{
menor_distancia = distancia_centroide;
melhor_cluster = cluster;
}
}
if (melhor_cluster != ponto->classe())
{
mudanca = true;
}
ponto->classe(melhor_cluster);
}
return mudanca;
}
void KMeans::agrupar(ConjuntoDeDados *dados)
{
ConjuntoDeDados * dados_estandardizados = dados->estandardizar();
vector<Ponto*> pontos = dados->pontos();
vector<Ponto*> pontos_estandardizados = dados_estandardizados->pontos();
for (size_t indice_ponto = 0; indice_ponto < pontos_estandardizados.size(); indice_ponto++)
{
Ponto * ponto = pontos_estandardizados.at(indice_ponto);
int cluster = rand() % _k;
ponto->classe(cluster);
}
bool mudanca = true;
while (mudanca)
{
vector<Ponto> centroides = atualizarCentroides(pontos_estandardizados);
mudanca = agruparPontos(&pontos_estandardizados, centroides);
}
for (size_t indice_ponto = 0; indice_ponto < pontos_estandardizados.size(); indice_ponto++)
{
Ponto * ponto = pontos_estandardizados.at(indice_ponto);
pontos.at(indice_ponto)->classe(ponto->classe());
}
}
vector<Ponto> KMeans::atualizarCentroides(vector<Ponto *> pontos)
{
vector<Ponto> centroides;
int dimensoes = pontos.at(0)->dimensoes();
for (int cluster = 0; cluster < _k; cluster++)
{
Ponto ponto(dimensoes, cluster);
centroides.push_back(ponto);
}
vector<int> contador_cluster;
contador_cluster.resize(_k, 0);
for (size_t indice_ponto = 0; indice_ponto < pontos.size(); indice_ponto++)
{
Ponto * ponto = pontos.at(indice_ponto);
int cluster = ponto->classe();
contador_cluster.at(cluster) = contador_cluster.at(cluster) + 1;
Ponto * centroide = ¢roides.at(cluster);
*centroide = *centroide + *ponto;
}
for (int cluster = 0; cluster < _k; cluster++)
{
Ponto * centroide = ¢roides.at(cluster);
if (contador_cluster.at(cluster) > 0)
{
*centroide = *centroide / contador_cluster.at(cluster);
}
}
return centroides;
}
void Filho::preparar() {
int tpontos = pontos.size(), lados = tpontos / 3, j;
buffer = buffer = (GLuint*)malloc(sizeof(GLuint)*tpontos * 3);
nvertices = tpontos * 3;
glEnableClientState(GL_VERTEX_ARRAY);
float *vertexB = (float *)malloc(sizeof(float)* nvertices);
j = 0;
for (int i = 0; i<tpontos; i++) {
Ponto xyz = pontos.at(i);
vertexB[j + 0] = xyz.getX();
vertexB[j + 1] = xyz.getY();
vertexB[j + 2] = xyz.getZ();
j += 3;
}
nvertices = j;
glGenBuffers(1, buffer);
glBindBuffer(GL_ARRAY_BUFFER, buffer[0]);
glBufferData(GL_ARRAY_BUFFER, nvertices*sizeof(float), vertexB, GL_STATIC_DRAW);
free(vertexB);
}
int main(int argc, char* argv[])
{
Ponto* p = new Ponto(5, 7);
p->Print();
printf("module = %f\n", p->getModule());
free(p);
return 0;
}
int main(int argc, char * argv[])
{
Ponto* p = new Ponto(5,7, 9);
p->print();
printf("p._x = %d\n", p->_x);
free(p);
return 0;
}
double Calculo::DistanciaPontos(Ponto & pontoA, Ponto & pontoB)
{
double deltaX= fabs(pontoA.PosicaoX() - pontoB.PosicaoX());
double deltaY= fabs(pontoA.PosicaoY() - pontoB.PosicaoY());
double deltaXElevado2= pow(deltaX,2);
double deltaYElevado2= pow(deltaY,2);
double distanciaEntreOsPontos= sqrt(deltaXElevado2 + deltaYElevado2);
return distanciaEntreOsPontos;
}
void Curva::calculaViewPort(Ponto min, Ponto max, int w, int h) {
vp_parametricas.clear();
vp_pontos.clear();
vp_tangentes.clear();
foreach (Ponto p, getParametricas()) {
Ponto vpponto;
vpponto.setX((w - 2*W_PONTO) * (p.getX() - min.getX()) / (max.getX() - min.getX()) + W_PONTO);
vpponto.setY((h - 2*W_PONTO) * (p.getY() - min.getY()) / (max.getY() - min.getY()) + W_PONTO);
vp_parametricas.append(vpponto);
}
void Clipping::clip(ObjetoGeometrico* objeto) {
Ponto* ponto = dynamic_cast<Ponto*>(objeto);
Reta* reta = dynamic_cast<Reta*>(objeto);
Poligono* poligono = dynamic_cast<Poligono*>(objeto);
Curva* curva = dynamic_cast<Curva*>(objeto);
if (ponto) {
clippingPonto(ponto->clone());
} else if (reta) {
clippingReta(reta->clone());
} else if (poligono) {
if (poligono->aberto) {
this->clippingObjetoGeometricoToRetas(poligono);
} else {
this->clippingPoligonoFechado(poligono);
}
} else if(curva){
this->clippingObjetoGeometricoToRetas(curva);
}
}
int main() {
Ponto a(10, 20);
Ponto b(30, 40);
Ponto c = a + b; //<=> a.operator +(b);
a.print();
b.print();
c.print();
/*IPonto t = a;
t.print();
IPonto *m = &a;
m->print();*/
// Ponto x = m; //Nao funciona. Do pai para o filho dah erro!
// x.print();
cout << soma<int>(10.0, 20.0) << endl;
cout << soma<float>(10.0, 20.0) << endl;
cout << soma<double>(10.0, 20.0) << endl;
/*{ // Escopo temporario
Ponto p(10,20);
p.print();
p.filho = new Ponto(20, 30);
p.filho->print();
}
Ponto **ppt = new Ponto*[2];
ppt[0] = new Ponto;
ppt[0]->print();
ppt[1] = new Ponto(70, 80);
ppt[1]->print();*/
return 0;
}
bool KMeans::testeF(ConjuntoDeDados *dados)
{
vector<Ponto*> pontos = dados->estandardizar()->pontos();
vector<Ponto> centroides = atualizarCentroides(pontos);
vector<int> contador_cluster;
contador_cluster.resize(_k, 0);
Ponto media_global(dados->dimensoes());
for (size_t indice_ponto = 0; indice_ponto < pontos.size(); indice_ponto++)
{
Ponto * ponto = pontos.at(indice_ponto);
int cluster = ponto->classe();
contador_cluster.at(cluster) = contador_cluster.at(cluster) + 1;
media_global = media_global + *ponto;
}
media_global = media_global / pontos.size();
Ponto sq_entre(dados->dimensoes());
for (size_t cluster = 0; cluster < centroides.size(); cluster++)
{
Ponto sq_cluster(dados->dimensoes());
sq_cluster = centroides.at(cluster) - media_global;
sq_cluster = sq_cluster * sq_cluster * contador_cluster.at(cluster);
sq_entre = sq_entre + sq_cluster;
}
Ponto sq_total(dados->dimensoes());
for (size_t indice_ponto = 0; indice_ponto < pontos.size(); indice_ponto++)
{
Ponto * ponto = pontos.at(indice_ponto);
Ponto sq_ponto(dados->dimensoes());
sq_ponto = *ponto - media_global;
sq_ponto = sq_ponto * sq_ponto;
sq_total = sq_total + sq_ponto;
}
Ponto sq_dentro = sq_total - sq_entre;
int d1 = min(_k - 1, DistribuicaoF::_max_d1);
int d2 = min((int)pontos.size() - _k, DistribuicaoF::_max_d2);
pair<int, int> indice_f(d1, d2);
Ponto sq_entre_bar = sq_entre / d1;
Ponto sq_dentro_bar = sq_dentro / d2;
Ponto f_score = sq_entre_bar / sq_dentro_bar;
for (int dimensao = 0; dimensao < dados->dimensoes(); dimensao++)
{
float valor_critico = DistribuicaoF::_distribuicao[indice_f];
if (f_score.at(dimensao) < valor_critico)
{
return false;
}
}
return true;
}
int MemoriaInterna::pontoToKey(const Ponto& p) {
int x = p.getX();
int y = p.getY();
int ret = ((unsigned char)p.getX() << 8) | (unsigned char)(p.getY());
return ret;
}
int MemoriaInterna::pontoToKey(const Ponto& p) {
int x = p.getX();
int y = p.getY();
int ret = (x - MAP_MIN) * MAP_DIM + (y - MAP_MIN);
return ret;
}
/*Acha pontos*/
pair<Ponto, Ponto> achaPonto(Ponto a, Ponto b, Ponto c){
Ponto p , q;
double ab, ac, bc, perimetro;
double semiperimetro;
double aq, ap, delta;
ab = a.len(b);
ac = a.len(c);
bc = b.len(c);
perimetro = ab + ac + bc;
semiperimetro = perimetro/2;
/***/
if(TESTE_NIVEL_1){
cout << "ACHAPONTO: AB = " << ab << endl;
cout << "ACHAPONTO: AC = " << ac << endl;
cout << "ACHAPONTO: BC = " << bc << endl;
cout << "ACHAPONTO: PERIMETRO = " << perimetro << endl;
}
/***/
delta = perimetro*perimetro - 8*ab*ac;
if(abs(delta) <= EPSILON) delta = 0;
if(delta >= 0){
aq = (perimetro + sqrt(delta))/4;
ap = (perimetro - sqrt(delta))/4;
if(ap > 0){
q = b - a;
q.setIntensidade(aq);
q = a + q;
if(a.len(q) < a.len(b) + EPSILON){
p = c - a;
p.setIntensidade(ap);
p = a + p;
if(a.len(p) < a.len(c) + EPSILON){
return make_pair(p,q);
}
}
else{
q = c - a;
q.setIntensidade(aq);
q = a + q;
if(a.len(q) < a.len(b) + EPSILON){
p = b - a;
p.setIntensidade(ap);
p = a + p;
if(a.len(p) < a.len(b) + EPSILON){
return make_pair(p,q);
}
}
}
}
else{
/***/
if(TESTE_NIVEL_1){
cout << "ACHAPONTO: ap negativo!" << endl;
}
/***/
}
}
else{
/***/
if(TESTE_NIVEL_1){
cout << "ACHAPONTO: delta negativo!" << endl;
}
/***/
}
return make_pair(inf, inf);
}
foreach (Ponto p, getPontos()) {
Ponto vpponto;
vpponto.setX((w - 2*W_PONTO) * (p.getX() - min.getX()) / (max.getX() - min.getX()) + W_PONTO);
vpponto.setY((h - 2*W_PONTO) * (p.getY() - min.getY()) / (max.getY() - min.getY()) + W_PONTO);
vp_pontos.append(vpponto);
}
