// Mnozenie wektora przez skalar Vect operator*(const Vect &p, double d) { Vect z(p.getDimension()); for(int i=0; i<p.getDimension(); i++) z.setCoordinate(i,d*p.getCoordinate(i)); return z; };
bool Env::sendMsg(long idSrc, long idDest, char *msg) { logMsg("SEND MSG : " + std::to_string(idSrc) + " -> " + std::to_string(idDest)); // if (this->phy->getNeighbours(idSrc).count(idDest)) { this->agents.at(idDest)->addMsg(msg); // Display the sending message with dataAgents Agent * agentSrc = this->agents.at(idSrc); Agent * agentDest = this->agents.at(idDest); Vect posSrc = PosToCell(agentSrc->getPos().x, agentSrc->getPos().y); Vect posDest = PosToCell(agentDest->getPos().x, agentDest->getPos().y); if (posSrc != posDest) { float dist = ((724-Vect(posSrc - posDest).Length()) / 724.0) / 6.0; for (float n = 0; n < 1; n += dist) { Vect base = posDest + n * (posSrc - posDest); Vect dirSommet = Vect(posSrc - posDest); dirSommet.Normalize(); Vect vectBase = Vect(dirSommet.y, -dirSommet.x); for (int j = 0; j < 20; j++) { for (int i = -j*0.5; i <= j*0.5; i++) { Vect point = base + j / 2.0 * dirSommet + i / 2.0 * vectBase; if (point.x >= 0 && point.x < 512 && point.y >= 0 && point.y < 512) { agentSrc->getVision(point.x, point.y)->dataAgent = 10 * (1 - n); } } } } } return true; //} //return false; }
Bounds Bounds::GetTransformedBounds(const Matrix &m) const { Bounds newBounds; BOOL bInitialized=0; for(int i=0; i<8; i++) { Vect p = GetPoint(i); p.TransformPoint(m); if(!bInitialized) { newBounds.Max = newBounds.Min = p; bInitialized = 1; } else { if(p.x < newBounds.Min.x) newBounds.Min.x = p.x; else if(p.x > newBounds.Max.x) newBounds.Max.x = p.x; if(p.y < newBounds.Min.y) newBounds.Min.y = p.y; else if(p.y > newBounds.Max.y) newBounds.Max.y = p.y; if(p.z < newBounds.Min.z) newBounds.Min.z = p.z; else if(p.z > newBounds.Max.z) newBounds.Max.z = p.z; } } return newBounds; }
JNIEXPORT void JNICALL Java_neuron_Neuron_vectorToHoc (JNIEnv *env, jclass, jlong jc, jdoubleArray ja, jint size) { Object* ho = (Object*)jc; Vect* vec = (Vect*)ho->u.this_pointer; vector_resize(vec, size); env->GetDoubleArrayRegion(ja, 0, size, &vec->elem(0)); }
void growVector() { CHECK (0 == Dummy::checksum()); { typedef typename Table<HO>::Type Vect; Vect table; table.reserve(2); CHECK (0 == Dummy::checksum()); cout << ".\n..install one element at index[0]\n"; table.push_back(HO()); CHECK (0 == Dummy::checksum()); create_contained_object (table[0]); // switches into "managed" state CHECK (0 < Dummy::checksum()); int theSum = Dummy::checksum(); cout << ".\n..*** resize table to 16 elements\n"; for (uint i=0; i<15; ++i) table.push_back(HO()); CHECK (theSum == Dummy::checksum()); } CHECK (0 == Dummy::checksum()); }
char AdapterComputationalGeometry::SegTriInt(Vect* T,Vect q,Vect r){ SegmentTriangleIntersection segmenttriangleintersection; tPointi Tpoints; tPointd qpoints; tPointd rpoints; tPointd ppoints; segmenttriangleintersection.Vertices[0][0]=T[0].getPunto().getX(); segmenttriangleintersection.Vertices[0][1]=T[0].getPunto().getY(); segmenttriangleintersection.Vertices[0][2]=T[0].getPunto().getZ(); segmenttriangleintersection.Vertices[1][0]=T[1].getPunto().getX(); segmenttriangleintersection.Vertices[1][1]=T[1].getPunto().getY(); segmenttriangleintersection.Vertices[1][2]=T[1].getPunto().getZ(); segmenttriangleintersection.Vertices[2][0]=T[2].getPunto().getX(); segmenttriangleintersection.Vertices[2][1]=T[2].getPunto().getY(); segmenttriangleintersection.Vertices[2][2]=T[2].getPunto().getZ(); Tpoints[0]=0; Tpoints[1]=1; Tpoints[2]=2; qpoints[0]=q.getPunto().getX(); qpoints[1]=q.getPunto().getY(); qpoints[2]=q.getPunto().getZ(); rpoints[0]=r.getPunto().getX(); rpoints[1]=r.getPunto().getY(); rpoints[2]=r.getPunto().getZ(); return segmenttriangleintersection.SegTriInt(Tpoints,qpoints,rpoints,ppoints); }
bool VerificacionNodosVecinosColapsoRegion::corrigeInconsistencia (Malla *malla, int indNodo){ assert(malla->getNodo(indNodo)!=NULL); Nodo* nodo=malla->getNodo(indNodo); Vect viejaNormal=nodo->getNormal(); Vect nuevaNormal; vector<int> indArcosVecinos=nodo->getArcos(); for (int indArco=0; indArco< (int)indArcosVecinos.size(); indArco++){ Arco* arcoVecino=malla->getArco(indArcosVecinos[indArco]); int indPuntoA=arcoVecino->getNodoDistinto(indNodo); Nodo* NodoA=malla->getNodo(indPuntoA); Vect vectorVecino=NodoA->getNormal()*(val*NodoA->getConcentracion()); nuevaNormal=nuevaNormal+vectorVecino; } //Normalizamos. nuevaNormal = nuevaNormal*(1/nuevaNormal.largo()); nodo->setNormal(nuevaNormal); //Si la inconsistencia no se corrige, borramos el nodo central. if (checkInterseccionNodo(malla,indNodo)==true){ nodo->setNormal(viejaNormal); colapsarRegion(malla,indNodo); return false; } else ntrayectoriasreparadas++; return true; }
BOOL Plane::GetIntersection(const Vect &p1, const Vect &p2, float &fT) const { float P1Dist = p1.DistFromPlane(*this); float P2Dist = p2.DistFromPlane(*this); if(CloseFloat(P1Dist, 0.0f, EPSILON)) { if(P2Dist == 0.0f) return 0; fT = 0.0f; return 1; } else if(CloseFloat(P2Dist, 0.0f, EPSILON)) { fT = 1.0f; return 1; } BOOL bP1Over = (P1Dist > 0.0f); BOOL bP2Over = (P2Dist > 0.0f); if(bP1Over == bP2Over) return FALSE; float P1AbsDist = fabs(P1Dist); float dist2 = (P1AbsDist+fabs(P2Dist)); if(dist2 < EPSILON) return FALSE; fT = P1AbsDist/dist2; return TRUE; }
void can_project_and_scale_points() { FrameBuffer fb(500, 500); Vect v = Vect(0, 0, 100); fb.projectAndScalePoint(v); ASSERT_EQUAL_FLOAT(v.getX(), 250, 0.1); ASSERT_EQUAL_FLOAT(v.getY(), 250, 0.1); }
const Vect Vect::getNorm()const { Vect norming = Vect(this->m); norming.norm(); return norming; };
void AnimController::setBonePose( PyramidObject *node ) { PyramidObject *childNode = (PyramidObject *)node; PyramidObject *parentNode = (PyramidObject *)node->getParent(); if( parentNode == GraphicsObjMan::getMainTree()->getRoot() ) return; if (parentNode != 0 && childNode != 0) { // Now get the world matrices Vect start(0.0f,0.0f,0.0f); parentNode->transform(); Vect ptA = start * parentNode->getWorld(); childNode->transform(); Vect ptB = start * childNode->getWorld(); // direction between the anchor points of the respective bones Vect dir = -(ptB - ptA); // length of the bone 0 float mag = dir.mag(); // Set the orientation and length for bone 0 Matrix S( SCALE, BONE_WIDTH, BONE_WIDTH, mag); Quat Q( ROT_ORIENT, dir.getNorm(), Vect( 0.0f, 1.0f, 0.0f) ); Matrix T( TRANS, ptB ); Matrix BoneOrient = S * Q * T; childNode->setBoneOrientation( BoneOrient ); } }
// Konstruktor kopiujacy Vect::Vect(const Vect &w) { dim = w.getDimension(); v = new double[w.getDimension()]; for (int i = 0; i < w.getDimension(); i++) setCoordinate(i, w.getCoordinate(i)); }
TEST(RayTracer, ray_inits) { Ray r(Vect(0, 0, -1), Vect(-1, 0, 0)); Vect o = r.getOrigin(); Vect d = r.getDirection(); CHECK_EQUAL(-1, o.getZ()); CHECK_EQUAL(-1, d.getX()); }
Vect operator*(const Vect &w, double d) { Vect r(w.getDimension()); r = w; for (int i = 0; i < w.getDimension(); i++) r.setCoordinate(i, d * w.getCoordinate(i)); return r; }
double operator*(const Vect &w1, const Vect &w2) { assert (w1.getDimension() == w2.getDimension()); double d = 0; for (int i = 0; i < w1.getDimension(); i++) d = d + w1.getCoordinate(i) * w2.getCoordinate(i); return d; }
Vect operator-(const Vect &w1, const Vect &w2) { assert (w1.getDimension() == w2.getDimension()); Vect w(w1.getDimension()); w = w1; w -= w2; return w; }
TEST(RayTracer, has_normalized_vectors) { RayTracer rt(10, 10); rt.setViewDirection(Vect(3, 4, 5)); Vect viewDir = rt.getViewDirection(); DOUBLES_EQUAL(0.424264, viewDir.getX(), 0.0001); DOUBLES_EQUAL(0.565685, viewDir.getY(), 0.0001); DOUBLES_EQUAL(0.707106, viewDir.getZ(), 0.0001); }
Vect operator*(const Vect &p, double d){ Vect k(p.getDimension()); for(int i = 1; i <= k.getDimension(); i++){ k.setCoordinate(i,p.getCoordinate(i)*d); } return k; }
void Rand::behaviour(AgentControl *agent) { if (t>10) { Vect force = Vect((rand() % 100) - 50, (rand() % 100) - 50); force.Normalize(); agent->getPhy()->applyForce(100*force); t = 0; } t++; }
void LinearMechanism::create() { int i; lmfree(); i = 0; Object* o = *hoc_objgetarg(++i); if (strcmp(o->ctemplate->sym->name, "PythonObject") == 0) { f_callable_ = o; hoc_obj_ref(o); c_ = matrix_arg(++i); } else { f_callable_ = NULL; c_ = matrix_arg(1); } g_ = matrix_arg(++i); y_ = vector_arg(++i); if (ifarg(i + 2) && hoc_is_object_arg(i + 2) && is_vector_arg(i + 2)) { y0_ = vector_arg(++i); } b_ = vector_arg(++i); if (ifarg(++i)) { #if HAVE_IV Oc oc; #endif if (hoc_is_double_arg(i)) { nnode_ = 1; nodes_ = new Node*[1]; double x = chkarg(i, 0., 1.); Section* sec = chk_access(); nodes_[0] = node_exact(sec, x); nrn_notify_when_double_freed(&NODEV(nodes_[0]), this); }else{ Object* o = *hoc_objgetarg(i); check_obj_type(o, "SectionList"); SectionList* sl = new SectionList(o); sl->ref(); Vect* x = vector_arg(i+1); Section* sec; nnode_ = 0; nodes_ = new Node*[x->capacity()]; for (sec = sl->begin(); sec; sec = sl->next()) { nodes_[nnode_] = node_exact(sec, x->elem(nnode_)); nrn_notify_when_double_freed(&NODEV(nodes_[nnode_]), this); ++nnode_; } if (ifarg(i+2)) { elayer_ = vector_arg(i+2); } sl->unref(); } } model_ = new LinearModelAddition(c_, g_, y_, y0_, b_, nnode_, nodes_, elayer_, f_callable_); }
JNIEXPORT jdoubleArray JNICALL Java_neuron_Neuron_vectorFromHoc (JNIEnv *env, jclass, jlong jc) { Object* ho = (Object*)jc; Vect* vec = (Vect*)ho->u.this_pointer; jint size = vec->capacity(); jdoubleArray ja = env->NewDoubleArray(size); env->SetDoubleArrayRegion(ja, 0, size, &vec->elem(0)); return ja; }
// Iloczyn skalarny double operator*(const Vect &p1, const Vect &p2) { assert (p1.getDimension() == p2.getDimension()); double wynik = 0; for(int i=0; i<p1.getDimension(); i++) wynik += (p1.getCoordinate(i) * p2.getCoordinate(i)); return wynik; };
Vect operator-(const Vect &p1, const Vect &p2) { assert(p1.getDimension() == p2.getDimension()); Vect p4(p1.getDimension()); p4 = p1; p4 -= p2; return p4; }
// Mno¿enie wektora przez skalar Vect operator*(const Vect &p, double d) { Vect g(p.getDimension()); for (int i=0; i<p.getDimension(); i++) g.setCoordinate(i,p.getCoordinate(i)*d); return g; }
BOOL Bounds::LineIntersection(const Vect &v1, const Vect &v2, float &fT) const { float tMax = M_INFINITE; float tMin = -M_INFINITE; Vect rayVect = (v2-v1); float rayLength = rayVect.Len(); Vect rayDir = rayVect*(1.0f/rayLength); Vect center = GetCenter(); Vect E = Max-center; Vect T = center-v1; for(int i=0; i<3; i++) { float e = T.ptr[i]; float f = rayDir.ptr[i]; float fI = 1.0f/f; if(fabs(f) > 0.0f) { float t1 = (e+E.ptr[i])*fI; float t2 = (e-E.ptr[i])*fI; if(t1 > t2) { if(t2 > tMin) tMin = t2; if(t1 < tMax) tMax = t1; } else { if(t1 > tMin) tMin = t1; if(t2 < tMax) tMax = t2; } if(tMin > tMax) return FALSE; if(tMax < 0.0f) return FALSE; } else if( ((-e - E.ptr[i]) > 0.0f) || ((-e + E.ptr[i]) < 0.0f) ) { return FALSE; } if(tMin > rayLength) return FALSE; } if(tMin > 0.0f) { fT = (tMin/rayLength); return TRUE; } else { fT = (tMax/rayLength); return TRUE; } }
void Shape::axisRotate(float deg){ Vertex centTemp(center.x, center.y, center.z); translate(-center.x, -center.y, -center.z);//Translate to origin Vertex origin(0,0,0); bool para = false; //Build movement matrix axis = chooseAxis(); Vect * ax = new Vect(origin, axis); Vect y(0,1.0, 0); Vect * v = Vect::unitVector(*ax); if(v->isParallel(y)){ v->x += .0000000001; } Vect * u = Vect::unitVector(*(Vect::crossProduct(*v, y))); Vect * n = Vect::unitVector(*(Vect::crossProduct(*u, *v))); //Align the global axis to the local axis: for(int i = 0; i < rs; i++){ for(int j = 0; j < vs; j++){ GLfloat x = verts[i][j].x; GLfloat y = verts[i][j].y; GLfloat z = verts[i][j].z; verts[i][j].x = u->x*x + u->y*y + u->z*z; verts[i][j].y = v->x*x + v->y*y + v->z*z; verts[i][j].z = n->x*x + n->y*y + n->z*z; x = vertsNorm[i][j].x; y = vertsNorm[i][j].y; z = vertsNorm[i][j].z; vertsNorm[i][j].x = u->x*x + u->y*y + u->z*z; vertsNorm[i][j].y = v->x*x + v->y*y + v->z*z; vertsNorm[i][j].z = n->x*x + n->y*y + n->z*z; } } //Rotate the amount needed. rotate(deg, 0, 1, 0); if(!para){ for(int i = 0; i < rs; i++){ for(int j = 0; j < vs; j++){ GLfloat x = verts[i][j].x; GLfloat y = verts[i][j].y; GLfloat z = verts[i][j].z; verts[i][j].x = u->x*x + v->x*y + n->x*z; verts[i][j].y = u->y*x + v->y*y + n->y*z; verts[i][j].z = u->z*x + v->z*y + n->z*z; x = vertsNorm[i][j].x; y = vertsNorm[i][j].y; z = vertsNorm[i][j].z; vertsNorm[i][j].x = u->x*x + v->x*y + n->x*z; vertsNorm[i][j].y = u->y*x + v->y*y + n->y*z; vertsNorm[i][j].z = u->z*x + v->z*y + n->z*z; } } } translate(centTemp.x, centTemp.y, centTemp.z); }
Vect operator-(const Vect &p1, const Vect &p2){ assert(p1.getDimension()==p2.getDimension()); Vect k(p1.getDimension()); for(int i = 1; i <= k.getDimension(); i++){ k.setCoordinate(i,p1.getCoordinate(i)-p2.getCoordinate(i)); } return k; }
Vect::Vect(const Vect &w){ dim = w.getDimension(); v = new double[w.getDimension()]; for(int i = 1; i <= dim; i++){ v[i-1]=w.getCoordinate(i); } }
double operator*(const Vect &p1, const Vect &p2){ assert(p1.getDimension()==p2.getDimension()); double output = 0; for(int i = 1; i <= p1.getDimension(); i++){ output += p1.getCoordinate(i)*p2.getCoordinate(i); } return output; }
BOOL Bounds::OutsidePlane(const Plane &p) const { Vect vmin; vmin.x = (*(DWORD*)&p.Dir.x & 0x80000000) ? Max.x : Min.x; vmin.y = (*(DWORD*)&p.Dir.y & 0x80000000) ? Max.y : Min.y; vmin.z = (*(DWORD*)&p.Dir.z & 0x80000000) ? Max.z : Min.z; return (vmin.Dot(p.Dir) > p.Dist); }