Label SVMClassifier::classify(const Descriptor &descriptor) const{ svm_node *nodes = constructNode(descriptor); //print::print_svm_nodes(nodes, descriptor.size()); double result = svm_predict(model, nodes); //vector<double> value_per_class = getValues(nodes, model); /* typedef Descriptor::const_iterator desit; cout << "descriptor: "; for(desit i = descriptor.begin(); i != descriptor.end(); ++i){ if((i - descriptor.begin()) % 10 == 0) cout << endl; cout << *i << " "; } cout << endl << "result: " << result << endl; */ delete [] nodes; return result; }
KDTree::KDTree(Object3d** p_objList, int p_objCount, int p_maxDepth, int p_minObjPerNode, bool p_verbose) { maxDepth = p_maxDepth; minObjPerNode = p_minObjPerNode; verbose = p_verbose; if(verbose) { printf("Using KD-Tree: %d depth | %d min obj p/ node\n", maxDepth, minObjPerNode); } time_t startTime = time(NULL); BoundingBox* totalBox = getTotalBoundingBox(p_objList, p_objCount); root = constructNode(p_objList, p_objCount, totalBox, KD_AXIS_NONE, 0); if(verbose) { printf(" KD-Tree took %d sec\n", (time(NULL) - startTime)); } }
Node DocumentImpl::createAttribute(const DOMString& name) { return constructNode(new AttrImpl(name)); }
Node DocumentImpl::createTextNode(const DOMString& data) { return constructNode(new TextImpl(data)); }
Node DocumentImpl::createElement(const DOMString& name) { return constructNode(new ElementImpl(name)); }
void SVMClassifier::addExampleToProblem(svm_problem *problem, const Example &example){ problem->y[problem->l] = (double) example.label; problem->x[problem->l] = constructNode(*example.descriptor); problem->l++; }
KDTreeNode * KDTree::constructNode(Object3d** p_objList, int p_objCount, BoundingBox* p_bbox, int p_parentAxis, int p_depth) { int depth = p_depth + 1; if(depth > maxDepth) { return NULL; } KDTreeNode * node = (KDTreeNode *) malloc(sizeof(KDTreeNode)); node->objList = p_objList; node->objCount = p_objCount; node->bbox = p_bbox; //this node's objects Object3d** objList; int objsOnNodeCount = 0; if(p_depth > 0) { short* objsOnNode = (short *)malloc(sizeof(short) * p_objCount); for(int i = 0; i < p_objCount; i++) { if(p_objList[i]->getBoundingBox()->intersects(p_bbox)) { objsOnNode[i] = 1; objsOnNodeCount++; } else { objsOnNode[i] = 0; } } if(objsOnNodeCount == p_objCount) { return NULL; } objList = new Object3d*[objsOnNodeCount]; int o = 0; for(int i = 0; i < p_objCount; i++) { if(objsOnNode[i] == 1) { objList[o++] = p_objList[i]; } } delete(objsOnNode); } else { objsOnNodeCount = p_objCount; objList = p_objList; } node->objCount = objsOnNodeCount; node->objList = objList; //process childs if(objsOnNodeCount < minObjPerNode) { node->leaf = true; node->child1 = NULL; node->child2 = NULL; //printf("LEAF2: %d < %d\n", objsOnNodeCount, minObjPerNode); } else { //the cut node->axis = chooseAxis(objList, objsOnNodeCount, p_bbox, p_parentAxis); node->cut = chooseCut(objList, objsOnNodeCount, p_bbox, node->axis); //cutted bouding boxes BoundingBox* bbox1 = new BoundingBox(p_bbox->x0, p_bbox->x1, p_bbox->y0, p_bbox->y1, p_bbox->z0, p_bbox->z1); BoundingBox* bbox2 = new BoundingBox(p_bbox->x0, p_bbox->x1, p_bbox->y0, p_bbox->y1, p_bbox->z0, p_bbox->z1); if(node->axis == KD_AXIS_X) { bbox1->x1 = node->cut; bbox2->x0 = node->cut; } else if(node->axis == KD_AXIS_Y) { bbox1->y1 = node->cut; bbox2->y0 = node->cut; } else if(node->axis == KD_AXIS_Z) { bbox1->z1 = node->cut; bbox2->z0 = node->cut; } //childs node->leaf = false; node->child1 = constructNode(objList, objsOnNodeCount, bbox1, p_parentAxis, depth); if(node->child1 != NULL) { node->child2 = constructNode(objList, objsOnNodeCount, bbox2, p_parentAxis, depth); } else { node->child2 = NULL; } if(node->child1 == NULL || node->child2 == NULL) { node->leaf = true; node->child1 = NULL; node->child2 = NULL; } } if(node->leaf && verbose) { printf(" -> %d\n", objsOnNodeCount); } return node; }
bool RegisterNodeMsgEx::processIncoming(struct sockaddr_in* fromAddr, Socket* sock, char* respBuf, size_t bufLen, HighResolutionStats* stats) { LogContext log("RegisterNodeMsg incoming"); std::string peer = fromAddr ? Socket::ipaddrToStr(&fromAddr->sin_addr) : sock->getPeername(); LOG_DEBUG_CONTEXT(log, Log_DEBUG, std::string("Received a RegisterNodeMsg from: ") + peer); App* app = Program::getApp(); NodeType nodeType = getNodeType(); std::string nodeID(getNodeID() ); NicAddressList nicList; BitStore nodeFeatureFlags; Node* node; uint16_t newNodeNumID; bool isNodeNew; LOG_DEBUG_CONTEXT(log, Log_SPAM, "Type: " + Node::nodeTypeToStr(nodeType) + "; " "NodeID: " + nodeID + "; " "NodeNumID: " + StringTk::uintToStr(getNodeNumID() ) ); // check for empty nodeID; (sanity check, should never fail) if(unlikely(nodeID.empty() ) ) { log.log(Log_WARNING, "Rejecting registration of node with empty string ID " "from: " + peer + "; " "type: " + Node::nodeTypeToStr(nodeType) ); return false; } // get the corresponding node store for this node type NodeStoreServers* servers = app->getServerStoreFromType(nodeType); if(unlikely(!servers) ) { log.logErr("Invalid node type for registration: " + Node::nodeTypeToStr(nodeType) + "; " "from: " + peer); newNodeNumID = 0; goto send_response; } // check if adding of new servers is allowed if(!checkNewServerAllowed(servers, getNodeNumID(), nodeType) ) { // this is a new server and adding was disabled log.log(Log_WARNING, "Registration of new servers disabled. Rejecting node: " + nodeID + " (Type: " + Node::nodeTypeToStr(nodeType) + ")"); newNodeNumID = 0; goto send_response; } // construct node parseNicList(&nicList); node = constructNode(nodeID, getNodeNumID(), getPortUDP(), getPortTCP(), nicList); node->setNodeType(getNodeType() ); node->setFhgfsVersion(getFhgfsVersion() ); parseNodeFeatureFlags(&nodeFeatureFlags); node->setFeatureFlags(&nodeFeatureFlags); // add node to store (or update it) isNodeNew = servers->addOrUpdateNodeEx(&node, &newNodeNumID); if(!newNodeNumID) { // unable to add node to store log.log(Log_WARNING, "Unable to add node with given numeric ID: " + StringTk::uintToStr(getNodeNumID() ) + "; " "string ID: " + getNodeID() + "; " "Type: " + Node::nodeTypeToStr(nodeType) ); goto send_response; } /* note on capacity pools: we may not add new nodes to capacity pools here yet, because at this point the registered node is not ready to receive messages yet. so we will add it to capacity pools later when we receive its first heartbeat msg. */ processIncomingRoot(getRootNumID(), nodeType); if(isNodeNew) { // this node is new processNewNode(nodeID, newNodeNumID, nodeType, getFhgfsVersion(), &nicList, peer); } // send response send_response: RegisterNodeRespMsg respMsg(newNodeNumID); respMsg.serialize(respBuf, bufLen); sock->sendto(respBuf, respMsg.getMsgLength(), 0, (struct sockaddr*)fromAddr, sizeof(struct sockaddr_in) ); return true; }