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;
}
