bool _split(node_t * root, node_t * p,
node_t * & t1, node_t * & t2)
{
if (!root) {
return false;
}
node_t *L = NULL, *R = NULL;
if (_split(root->lc, p, L, R)) {
root->lc = R;
t1 = L;
t2 = root;
return true;
}
if (root == p) {
t1 = root->lc;
t2 = root;
root->lc = NULL;
return true;
}
if (_split(root->rc, p, L, R)) {
root->rc = L;
t1 = root;
t2 = R;
return true;
}
return false;
}
void _split(T A[], T temp[], int begin, int end)
{
if ((end - begin) < 2)
return;
// recursively split into halves until size is 1,
// then merge and go back up.
int mid = (end + begin) / 2;
// I chose 16 because it's a power of 2 and precedence.
if ((end - mid) <= 16)
{
insertion_sort(A, end, mid); // mid included.
insertion_sort(A, mid, begin); // mid excluded.
}
// Split if large enough.
else
{
_split(A, temp, begin, mid); // mid will be excluded.
_split(A, temp, mid, end); // mid will be included.
}
_merge(A, temp, begin, mid, end); // merge them back again.
_copy (A, temp, begin, end); // Copy sorted array to original array.
}
void MeshTextureGraphicsItem::_drawQuad(const Texture& texture, const Quad& inputQuad, const Quad& outputQuad, float outputArea, float inputThreshod, float outputThreshold)
{
QPointF oa = mapFromScene(outputQuad.getVertex(0));
QPointF ob = mapFromScene(outputQuad.getVertex(1));
QPointF oc = mapFromScene(outputQuad.getVertex(2));
QPointF od = mapFromScene(outputQuad.getVertex(3));
QPointF ia = inputQuad.getVertex(0);
QPointF ib = inputQuad.getVertex(1);
QPointF ic = inputQuad.getVertex(2);
QPointF id = inputQuad.getVertex(3);
// compute the dot products for the polygon
float outputV1dotV2 = QPointF::dotProduct(oa-ob, oc-ob);
float outputV3dotV4 = QPointF::dotProduct(oc-od, oa-od);
float outputV1dotV4 = QPointF::dotProduct(oa-ob, oa-od);
float outputV2dotV3 = QPointF::dotProduct(oc-ob, oc-od);
// compute the dot products for the texture
float inputV1dotV2 = QPointF::dotProduct(ia-ib, ic-ib);
float inputV3dotV4 = QPointF::dotProduct(ic-id, ia-id);
float inputV1dotV4 = QPointF::dotProduct(ia-ib, ia-id);
float inputV2dotV3 = QPointF::dotProduct(ic-ib, ic-id);
// Stopping criterion.
if (outputArea < 200 ||
(fabs(outputV1dotV2 - outputV3dotV4) < outputThreshold &&
fabs(outputV1dotV4 - outputV2dotV3) < outputThreshold &&
fabs(inputV1dotV2 - inputV3dotV4) < inputThreshod &&
fabs(inputV1dotV4 - inputV2dotV3) < inputThreshod))
{
glBegin(GL_QUADS);
for (int i = 0; i < outputQuad.nVertices(); i++)
{
Util::setGlTexPoint(texture, inputQuad.getVertex(i), mapFromScene(outputQuad.getVertex(i)));
}
glEnd();
}
else // subdivide
{
QList<Quad> inputSubQuads = _split(inputQuad);
QList<Quad> outputSubQuads = _split(outputQuad);
for (int i = 0; i < inputSubQuads.size(); i++)
{
_drawQuad(texture, inputSubQuads[i], outputSubQuads[i], outputArea*0.25, inputThreshod, outputThreshold);
}
}
}
int line_processor (struct line_read_state * state, char * line, int len, int counter, int err_code){
if(err_code != _GETLINE_NONE && err_code != _GETLINE_EOF) return -1;
if(len > 0){
state->line_counter++;
if(state->line_counter == 1){
return init_complex_pipe(&state->pipe, create_exec_args(line));
}else{
struct str_splited_pair pointers [3];
int cnt = _split(line, " ", pointers, 2);
if(cnt < 2){
_print(STDERR_FILENO, "Wrong format!\n");
return 0;
}
*pointers[0].end = '\0';
*pointers[1].end = '\0';
if(strcmp(pointers[0].start, "->") == 0){
return bind_left(&state->pipe, create_exec_args(pointers[1].start));
}else if(strcmp(pointers[0].start, "<-") == 0){
return bind_right(&state->pipe, create_exec_args(pointers[1].start));
}else{
_print(STDERR_FILENO, "Wrong format!\n");
return 0;
}
}
}else{
return 1;
}
return 0;
}
void fbuf_connect(FBUF* b, FBUF* x, uint8_t pos)
{
register uint8_t islot = x->head;
register uint8_t p = pos;
while (p >= FBUF_SLOTSIZE) {
p -= _fbuf_length[islot];
if (p > 0)
islot = _fbuf_next[islot];
}
/* Find last slot of b and connect it to rest of x */
register uint8_t xlast = b->head;
while (_fbuf_next[xlast] != NILPTR)
xlast = _fbuf_next[xlast];
_fbuf_next[xlast] = _split(islot, p);
/* Increment reference count of rest of x */
while (_fbuf_next[xlast] != NILPTR) {
xlast = _fbuf_next[xlast];
_fbuf_refcnt[xlast]++;
}
b->wslot = x->wslot = NILPTR; // Disallow writing
b->length = b->length + x->length - pos;
}
int main (int argc, char *argv[]) {
dsr_t hdr;
uint8_t *img;
uint8_t pref;
pref = 1;
img = NULL;
startup("cutimg", argc, argv, NULL, NULL);
if (argc != 3 && argc != 4) {
printf("usage: cutimg input outdir [prefix]\n");
goto fail;
}
if (argc == 4) pref = atoi(argv[3]);
if (analyze_load(argv[1], &hdr, &img)) goto fail;
if (_split(&hdr, img, argv[2], pref)) goto fail;
free(img);
return 0;
fail:
printf("Cut failed\n");
if (img != NULL) free(img);
return 1;
}
void _insert(bp_tree * tree, int k)
{
if (!tree->root) {
bp_node * r = new bp_node;
r->n = 1;
r->key[0] = k;
tree->root = tree->sqt = r;
return;
}
bp_node * p = NULL;
int i = -1;
if (_find(tree->root, k, p, i)) {
return;
}
_insert_key(p, i, k);
while (p->n == 4) {
bp_node *n1 = NULL, *n2 = NULL;
bp_node * parent = p->parent;
_split(p, n1, n2);
if (!parent) {
tree->root = parent = new bp_node;
}
_insert_child(parent, n1, n2);
p = parent;
}
}
QStringList zuluMountTask::hiddenVolumeList()
{
QFile f( _excludeVolumePath() ) ;
if( f.open( QIODevice::ReadOnly ) ){
QVector< deviceList > l = _getDevices() ;
QStringList e ;
QStringList g = _split( f ) ;
for( const auto& it : l ){
if( g.contains( it.uniqueName ) ){
e.append( it.device ) ;
}
}
return e ;
}else{
return QStringList() ;
}
}
bool run(const string& , BSONObj& cmdObj, string& errmsg, BSONObjBuilder& result, bool){
ShardConnection::sync();
string ns = cmdObj.firstElement().valuestrsafe();
if ( ns.size() == 0 ){
errmsg = "no ns";
return false;
}
DBConfigPtr config = grid.getDBConfig( ns );
if ( ! config->isSharded( ns ) ){
errmsg = "ns not sharded. have to shard before can split";
return false;
}
BSONObj find = cmdObj.getObjectField( "find" );
if ( find.isEmpty() ){
find = cmdObj.getObjectField( "middle" );
if ( find.isEmpty() ){
errmsg = "need to specify find or middle";
return false;
}
}
ChunkManagerPtr info = config->getChunkManager( ns );
ChunkPtr old = info->findChunk( find );
return _split( result , errmsg , ns , info , old , cmdObj.getObjectField( "middle" ) );
}
bool ShaderFile::addShader(const std::string& fname, const std::string& define)
{
// Clear last stuff if there is any
mFileName.clear();
mDirectory.clear();
Log::message("Parsing shader file '%s'", fname.c_str());
// Split the string into dir/filename/extension
std::string ext, dir, filen;
Utilities::splitPath(fname, &dir, &filen, &ext);
mFileName = filen + ext;
mDirectory = dir;
mDefineString = define;
std::string source;
if (!Utilities::fileToString(mDirectory + mFileName, source))
{
Log::error("Unable to open file '%s'", fname.c_str());
return false;
}
_split(source);
return true;
}
void PertyWaySplitVisitor::visit(const shared_ptr<Element>& e)
{
//LOG_DEBUG(e->getElementType());
if (OsmSchema::getInstance().isLinearHighway(e->getTags(), e->getElementType()))
{
_split(e);
}
}
void merge_sort(T A[], const int size)
{
// No point in sorting if array doesn't point to anything or has but 1 element.
if ((A == nullptr) || (size <= 1))
return;
T temp[size];
_split(A, temp, 0, size);
// Will automatically delete temp when loses scope.
}
void TreeEqualizer::_split( Node* node )
{
if( node->compound )
return;
LBASSERT( node->left && node->right );
Node* left = node->left;
Node* right = node->right;
// easy outs
if( left->resources == 0.f )
{
node->split = 0.f;
return;
}
if( right->resources == 0.f )
{
node->split = 1.f;
return;
}
// new split
const float target = node->time * left->resources / node->resources;
const float leftTime = float(left->time);
float split = 0.f;
const float rightTime = float(right->time);
if( leftTime >= target )
split = target / leftTime * node->split;
else
{
const float timeLeft = target - leftTime;
split = node->split + timeLeft / rightTime * ( 1.f - node->split );
}
LBLOG( LOG_LB2 )
<< "Should split at " << split << " (" << target << ": " << leftTime
<< " by " << left->resources << "/" << rightTime << " by "
<< right->resources << ")" << std::endl;
node->split = (1.f - _damping) * split + _damping * node->split;
LBLOG( LOG_LB2 ) << "Dampened split at " << node->split << std::endl;
_split( left );
_split( right );
}
void split(node_t * root, int x, node_t * & t1, node_t * & t2)
{
if (!root) {
return;
}
node_t * p = _find_x(root, x);
if (!p) {
if (root->data > x) {
t2 = root;
}
else {
t1 = root;
}
return;
}
_split(root, p, t1, t2);
}
void SplayTree::insert(int key, int position) {
size_t treeSize = (_root ? _root->sizeOfSubtree : 0);
if(position > treeSize) {
return;
// throw std::out_of_range("out of range in SplayTree::insert\n");
}
SplayTree* rightTree = _split(position);
Node* newRoot = new Node(key);
newRoot->leftChild = _root;
newRoot->rightChild = rightTree->_root;
_root = newRoot;
_keepParent(_root);
Node::updateNodeParams(_root);
rightTree->_root = NULL;
rightTree->~SplayTree();
}
void * allocate(std::size_t size, std::size_t alignment = alignof(std::max_align_t))
{
if (size < platform::min_chunk_size)
{
assert("TODO");
}
else
{
for (auto bin = _get_bin(size); bin != _bins.end(); ++bin)
{
std::unique_lock<platform::lock> lock{ bin->lock };
if (bin == _bins.end() - 1 && !bin->first)
{
bin->first = _allocate_chunk();
}
if (bin->first)
{
auto chunk = bin->first;
bin->first = chunk->next;
while (chunk->chunk_size >= 2 * size && bin != _bins.begin())
{
chunk = _split(chunk);
}
chunk->next = nullptr;
chunk->prev = nullptr;
chunk->bin = nullptr;
chunk->allocation_size = size;
chunk->state = _chunk_state::allocated;
return reinterpret_cast<void *>(chunk->address);
}
}
}
}
void zuluMountTask::removeVolumeFromHiddenVolumeList( const QString& e )
{
QFile f( _excludeVolumePath() ) ;
if( f.open( QIODevice::ReadOnly ) ){
QStringList l = _split( f ) ;
l.removeAll( _getUniqueName( e ) ) ;
f.close() ;
if( f.open( QIODevice::WriteOnly | QIODevice::Truncate ) ){
if( !l.isEmpty() ){
for( const auto& it : l ){
f.write( it.toLatin1() + "\n" ) ;
}
}
}
}
}
void fbuf_insert(FBUF* b, FBUF* x, uint8_t pos)
{
register uint8_t islot = b->head;
while (pos >= FBUF_SLOTSIZE) {
pos -= _fbuf_length[islot];
if (pos > 0)
islot = _fbuf_next[islot];
}
/* Find last slot in x chain and increment reference count*/
register uint8_t xlast = x->head;
_fbuf_refcnt[xlast]++;
while (_fbuf_next[xlast] != NILPTR) {
xlast = _fbuf_next[xlast];
_fbuf_refcnt[xlast]++;
}
/* Insert x chain after islot */
_fbuf_next[xlast] = _split(islot, pos);
_fbuf_next[islot] = x->head;
b->wslot = x->wslot = NILPTR; // Disallow writing
b->length += x->length;
}
std::vector<std::string>
BaseParser::_split( const std::string & input, const std::string & str ) {
std::regex regex(str);
return _split( input, regex );
}
NeuronDatareader::NeuronDatareader(char * file, char * labels)
{
try
{
_file = _split(file, '.', _file);
_label = _split(labels, '.', _label);
if(!std::strcmp(_file.at(1).c_str(),"idx3-ubyte"))
{
if(!std::strcmp(_label.at(1).c_str(),"idx1-ubyte"))
{
_filetype = Fileformat::idx;
}
}
_dimensions = 0;
_size[0]=_size[1]=_size[2] = 1;
_lsize[0]=_lsize[1]=_lsize[2] = 1;
std::fstream filestream;
std::fstream labelstream;
filestream.open(file, std::ios::in|std::ios::binary);
labelstream.open(labels, std::ios::in|std::ios::binary);
bool open = filestream.is_open()&&labelstream.is_open();
std::cout <<"IsOpen? "<< open<<" " <<file <<" " << labels<<std::endl;
std::cout <<"Stream Read!"<<std::endl;
std::cout <<"Get Header Information!"<< std::endl;
_magicnumber = (filestream.get()<<24)|(filestream.get()<<16)|(filestream.get()<<8)|filestream.get();
_nmb_items = (filestream.get()<<24)|(filestream.get()<<16)|(filestream.get()<<8)|filestream.get();
_dimensions = _magicnumber&(0x000000ff);
_item_type = (_magicnumber&(0x0000ff00))>>8;
_lmagicnumber = (labelstream.get()<<24)|(labelstream.get()<<16)|(labelstream.get()<<8)|labelstream.get();
_lnmb_items = (labelstream.get()<<24)|(labelstream.get()<<16)|(labelstream.get()<<8)|labelstream.get();
_ldimensions = _lmagicnumber&(0x000000ff);
_litem_type = (_lmagicnumber&(0x0000ff00))>>8;
switch(_dimensions)
{
case 0: //scalar
_dimensions = 0;
break;
case 1: //1D
_dimensions = 1;
break;
case 2: //2D
_dimensions = 2;
break;
case 3: //3D
_dimensions = 2;
break;
}
switch(_ldimensions)
{
case 0: //scalar
_ldimensions = 0;
break;
case 1: //1D
_ldimensions = 0;
break;
case 2: //2D
_ldimensions = 2;
break;
case 3: //3D
_ldimensions = 2;
break;
}
switch(_item_type)
{
case 0x08:
//unsigned byte
_item_size = 8;
break;
case 0x09:
//signed byte
_item_size = 8;
break;
case 0x0b:
//short
_item_size = 16;
break;
case 0x0c:
//int
_item_size = 32;
break;
case 0x0d:
//float
_item_size = 32;
break;
case 0x0e:
//double
_item_size = 64;
break;
}
switch(_litem_type)
{
case 0x08:
//unsigned byte
_litem_size = 8;
break;
case 0x09:
//signed byte
_litem_size = 8;
break;
case 0x0b:
//short
_litem_size = 16;
break;
case 0x0c:
//int
_litem_size = 32;
break;
case 0x0d:
//float
_litem_size = 32;
break;
case 0x0e:
//double
_litem_size = 64;
break;
}
for(int c=0; c <_dimensions; c++)
{
_size[c] = (filestream.get()<<24)|(filestream.get()<<16)|(filestream.get()<<8)|filestream.get();
}
for(int c=0; c <_ldimensions; c++)
{
_lsize[c] = (filestream.get()<<24)|(filestream.get()<<16)|(filestream.get()<<8)|filestream.get();
}
_inputsize = _size[0]*_size[1]*_size[2];
Filetype value;
Imagetype img;
int cnt=0;
int img_index = 0;
for(int dataset_cnt = 0; dataset_cnt < _nmb_items; dataset_cnt++,cnt++)
{
img.val = new Filetype[_inputsize];
memset(img.val, 0, _inputsize*sizeof(Filetype));//Set Image to 0
for(int dep_c=0; dep_c < _size[2]; dep_c++) //Z
{
for(int col_c=0; col_c < _size[1]; col_c++) //Y
{
for(int row_c = 0; row_c <_size[0]; row_c++) //X
{
memset(&value, 0, sizeof(Filetype)); //SetPixel to 0
int shift = 0;
unsigned char bla = 0;
for(int val_c = 0; val_c < _item_size/8 ; val_c++)//Read Byte-wise
{
shift = (_item_size-8-(val_c*8));
bla = filestream.get();
value.ulong |= ((unsigned long)bla)<< shift; //SetPixel
}
img_index = row_c+col_c*_size[0]+dep_c*_size[0]*_size[1];
value.sfloat = value.ulong/(std::pow(2, _item_size)-1.0f);//norm
img.val[img_index] = value; //Save Pixel in image
}
}
}
img.img_size = _size[0]*_size[1]*_size[2];
_data.push_back(img);//Pushback in data-array
}
/*
for(int c2 = 0; c2 < _size[1]; c2++)
{
for(int c1=0; c1 < _size[0]; c1++)
{
int val = (_data.at(0).val[c1+c2*_size[0]].uchar);
std::cout << std::setw(2) << std::setfill('0') << std::hex << (val);
}
std::cout << std::endl;
}
*/
_linputsize = 10;
unsigned char label_data = 0;
Imagetype label_img;
for(int dataset_cnt = 0; dataset_cnt < _lnmb_items; dataset_cnt++)
{
label_img.val = new Filetype[_linputsize];
label_img.img_size = _linputsize;
label_data=labelstream.get();
_ldata.push_back(label_data);
//label_vec
for(int index = 0; index < _linputsize; index++)
{
value.sfloat = (label_data == index)?(1.0f):(0.0f);
label_img.val[index] = value;
}
_ldata_vec.push_back(label_img);
}
_indexes.resize(_ldata.size());
for (unsigned int i = 0; i < _indexes.size(); ++i)
_indexes.at(i) = i;
std::random_shuffle(_indexes.begin(), _indexes.end());
std::cout << "Feddich!" << std::endl;
}
catch(std::exception & exp)
{
std::cout << exp.what() << std::endl;
throw _EXP_FLAG_READ;
}
//ctor
}
vector<ElementPtr> PertyWaySplitVisitor::_split(ElementPtr element)
{
//randomly select elements and split them into two parts
boost::uniform_real<> randomSplitDistribution(0.0, 1.0);
const double randomSplitNum = randomSplitDistribution(*_rng);
if (randomSplitNum <= _waySplitProbability)
{
LOG_DEBUG("element " << element->getElementId() << " *will* be split based on a split " <<
"probability of: " << _waySplitProbability << " and a randomly generated number: " <<
randomSplitNum << "\n");
_splitRecursionLevel++;
LOG_VARD(_splitRecursionLevel);
const int numNodesBeforeSplit = _map->getNodeMap().size();
LOG_VARD(numNodesBeforeSplit);
const int numWaysBeforeSplit = _map->getWays().size();
LOG_VARD(numWaysBeforeSplit);
WayLocation waySplitPoint;
MultiLineStringLocation multiLineSplitPoint;
QList<long> nodeIdsBeforeSplit;
int segmentIndex = -1;
ElementId wayId;
//determine where to split the element
if (element->getElementType() == ElementType::Way)
{
WayPtr way = dynamic_pointer_cast<Way>(element);
LOG_VARD(way->getNodeCount());
nodeIdsBeforeSplit = QVector<long>::fromStdVector(way->getNodeIds()).toList();
LOG_VARD(nodeIdsBeforeSplit);
waySplitPoint = _calcSplitPoint(way);
}
else
{
multiLineSplitPoint = _calcSplitPoint(dynamic_pointer_cast<Relation>(element), wayId);
waySplitPoint = multiLineSplitPoint.getWayLocation();
}
const QString distanceMsgStrEnd =
QString("a minimum node spacing of ")
.append(QString::number(_minNodeSpacing))
.append(" meters");
if (!waySplitPoint.isValid())
{
_splitRecursionLevel--;
LOG_VARD(_splitRecursionLevel);
LOG_DEBUG("split point *will not* be used because *it violates* " << distanceMsgStrEnd);
//if it violates the min node spacing, return an empty element collection, which will end the
//recursive splitting on the current way
return vector<ElementPtr>();
}
else
{
LOG_DEBUG("split point *will* be used because it *does not* violate " << distanceMsgStrEnd);
segmentIndex = waySplitPoint.getSegmentIndex();
LOG_VARD(segmentIndex);
}
//split the element
vector<ElementPtr> newElementsAfterSplit;
if (element->getElementType() == ElementType::Way)
{
vector<WayPtr> newWaysAfterSplit =
WaySplitter::split(_map->shared_from_this(), dynamic_pointer_cast<Way>(element), waySplitPoint);
for (size_t i = 0; i < newWaysAfterSplit.size(); i++)
{
newElementsAfterSplit.push_back(newWaysAfterSplit.at(i));
}
}
else
{
ElementPtr match;
MultiLineStringSplitter().split(_map->shared_from_this(), multiLineSplitPoint, match);
newElementsAfterSplit.push_back(match);
}
const int numNodesAfterSplit = _map->getNodeMap().size();
LOG_VARD(numNodesAfterSplit);
const int numNewNodesCreatedBySplit = numNodesAfterSplit - numNodesBeforeSplit;
LOG_VARD(numNewNodesCreatedBySplit);
LOG_VARD(_map->getWays().size());
if (numNewNodesCreatedBySplit > 0)
{
WayPtr way = dynamic_pointer_cast<Way>(element);
//Its possible that the splitting of a relation could generate a new node. In that case,
//_updateNewNodeProperties does not need to be called b/c the MultiLineStringSplitter has
//already properly updated the new node's properties. when a way is split, however, the
//new node's properties must be updated by the call to _updateNewNodeProperties.
if (way != 0)
{
assert(nodeIdsBeforeSplit.size() > 0);
//update properties on any nodes added as a result of the way splitting (new ways created as a
//result of the splitting will already have had their parent's tags added by WaySplitter)
_updateNewNodeProperties(
_getNodeAddedBySplit(nodeIdsBeforeSplit, newElementsAfterSplit),
_map->getNode(way->getNodeId(segmentIndex)),
_map->getNode(way->getNodeId(segmentIndex + 1)));
}
}
//recursive call
for (vector<ElementPtr>::const_iterator it = newElementsAfterSplit.begin();
it != newElementsAfterSplit.end(); it++)
{
_split(*it);
}
return newElementsAfterSplit;
}
else
{
LOG_DEBUG("element " << element->getElementId() << " *will not* be split based on a split " <<
"probability of: " << _waySplitProbability << " and a randomly generated number: " <<
randomSplitNum << "\n");
}
//end the recursive splitting on the current way
return vector<ElementPtr>();
}
void
split(const StaticString &str, char sep, vector<StaticString> &output) {
_split(str, sep, output);
}
