QgsAttributeTableModel::QgsAttributeTableModel( QgsVectorLayer *theLayer, QObject *parent )
: QAbstractTableModel( parent )
{
mFeat.setFeatureId( std::numeric_limits<int>::min() );
mLayer = theLayer;
loadAttributes();
connect( mLayer, SIGNAL( attributeValueChanged( int, int, const QVariant& ) ), this, SLOT( attributeValueChanged( int, int, const QVariant& ) ) );
connect( mLayer, SIGNAL( featureAdded( int ) ), this, SLOT( featureAdded( int ) ) );
connect( mLayer, SIGNAL( featureDeleted( int ) ), this, SLOT( featureDeleted( int ) ) );
connect( mLayer, SIGNAL( attributeAdded( int ) ), this, SLOT( attributeAdded( int ) ) );
connect( mLayer, SIGNAL( attributeDeleted( int ) ), this, SLOT( attributeDeleted( int ) ) );
loadLayer();
}
void QgsAttributeTableModel::loadLayer()
{
// make sure attributes are properly updated before caching the data
// (emit of progress() signal may enter event loop and thus attribute
// table view may be updated with inconsistent model which may assume
// wrong number of attributes)
loadAttributes();
beginResetModel();
if ( rowCount() != 0 )
{
removeRows( 0, rowCount() );
}
// Layer might have been deleted and cache set to nullptr!
if ( mLayerCache )
{
QgsFeatureIterator features = mLayerCache->getFeatures( mFeatureRequest );
int i = 0;
QTime t;
t.start();
while ( features.nextFeature( mFeat ) )
{
++i;
if ( t.elapsed() > 1000 )
{
bool cancel = false;
emit progress( i, cancel );
if ( cancel )
break;
t.restart();
}
featureAdded( mFeat.id(), true );
}
emit finished();
connect( mLayerCache, &QgsVectorLayerCache::invalidated, this, &QgsAttributeTableModel::loadLayer, Qt::UniqueConnection );
}
endResetModel();
}
void CCharacter::Init(Vector2 *position) {
//CXMLParser *data = new CXMLParser("sakuya");
CXMLParser *xmlRaw = new CXMLParser(_name);
//xmlRaw->printData();
_position = new Vector2(*position);
_groundY = _position->getY();
_jumping = CInputs::DirStand;
_maxActiveMovement = 5;
loadAttributes(xmlRaw->getDataByTag("data"));
loadPalette();
loadMovements(xmlRaw->getDataByTag("movements"));
loadProjMovements(xmlRaw->getDataByTag("projMovements"));
//_currentMovement = &_movementList[0];
//_currentMovement->StartMovement(_position);
_indexMovement = (u16)CInputs::Stand;
_movementList[_indexMovement]->StartMovement();
//delete xmlRaw;
} // Init
void QgsAttributeTableModel::updatedFields()
{
QgsDebugMsg( "entered." );
loadAttributes();
emit modelChanged();
}
void QgsAttributeTableModel::setExtraColumns( int extraColumns )
{
mExtraColumns = extraColumns;
loadAttributes();
}
void QgsAttributeTableModel::updatedFields()
{
loadAttributes();
emit modelChanged();
}
SEXP random_ferns(SEXP sAttributes,SEXP sDecision,SEXP sD,SEXP sNumFerns,SEXP sCalcImp,SEXP sOobErrEvery,SEXP sHoldForest,SEXP sMultilabel,SEXP sConsSeed){
struct attribute *X;
uint nAtt,nObj,nClass,*Y;
uint multi=INTEGER(sMultilabel)[0];
loadAttributes(sAttributes,&X,&nAtt,&nObj);
if(!multi){
nClass=length(getAttrib(sDecision,R_LevelsSymbol));
//Sadly, we need to copy
Y=(uint*)R_alloc(sizeof(uint),nObj);
for(uint e=0;e<nObj;e++)
Y[e]=INTEGER(sDecision)[e]-1;
}else{
nClass=length(sDecision)/nObj;
Y=(uint*)R_alloc(sizeof(uint),nObj*nClass);
for(uint e=0;e<nObj*nClass;e++)
Y[e]=LOGICAL(sDecision)[e];
}
//Now, let's make the RNG and seed from R's RNG
EMERGE_R_FROM_R;
//Data loaded, time to load parameters
params Q;
Q.numClasses=nClass;
Q.D=INTEGER(sD)[0];
Q.twoToD=1<<(Q.D);
Q.numFerns=INTEGER(sNumFerns)[0];
Q.repOobErrEvery=abs(INTEGER(sOobErrEvery)[0]);
Q.holdOobErr=INTEGER(sOobErrEvery)[0]>0;
Q.calcImp=INTEGER(sCalcImp)[0]; //0->none, 1->msl, 2->msl+sha
Q.holdForest=INTEGER(sHoldForest)[0];
Q.multilabel=multi;
if(Q.calcImp==2){
Q.consSeed=((uint64_t*)INTEGER(sConsSeed))[0];
}else{
Q.consSeed=0;
}
//Start composing answer
SEXP sAns; PROTECT(sAns=allocVector(VECSXP,5));
//Allocating fern forest; the whole space is controlled by R
ferns ferns;
SEXP sfSplitAtts=R_NilValue;
SEXP sfScores=R_NilValue;
if(Q.holdForest){
//To store the forest, we allocate vectors which will contain it
// and build ferns out of their buffers. The rest is in saving forest.
PROTECT(sfSplitAtts=allocVector(INTSXP,(Q.D)*(Q.numFerns)));
ferns.splitAtts=INTEGER(sfSplitAtts);
ferns.thresholds=(thresh*)R_alloc(sizeof(thresh),(Q.D)*(Q.numFerns));
PROTECT(sfScores=allocVector(REALSXP,(Q.twoToD)*(Q.numClasses)*(Q.numFerns)));
ferns.scores=(score_t*)REAL(sfScores);
}else{
//In the opposite case, we allocate a chunk for 1-fern forest on GC heap
ferns.splitAtts=(int*)R_alloc(Q.D,sizeof(int));
ferns.thresholds=(thresh*)R_alloc(Q.D,sizeof(thresh));
ferns.scores=(double*)R_alloc((Q.numClasses)*(Q.twoToD),sizeof(double));
}
//Fire the code
model *M=makeModel(X,nAtt,Y,nObj,&ferns,&Q,_R);
//Saving forest
if(Q.holdForest){
SEXP sfThreReal; PROTECT(sfThreReal=allocVector(REALSXP,(Q.D)*(Q.numFerns)));
SEXP sfThreInt; PROTECT(sfThreInt=allocVector(INTSXP,(Q.D)*(Q.numFerns)));
for(uint e=0;e<(Q.D)*(Q.numFerns);e++){
if(X[ferns.splitAtts[e]].numCat!=0){
INTEGER(sfThreInt)[e]=ferns.thresholds[e].selection;
REAL(sfThreReal)[e]=NAN;
}else{
INTEGER(sfThreInt)[e]=-1;
REAL(sfThreReal)[e]=ferns.thresholds[e].value;
}
}
SEXP sModel; PROTECT(sModel=allocVector(VECSXP,4));
SET_VECTOR_ELT(sModel,0,sfSplitAtts);
SET_VECTOR_ELT(sModel,1,sfThreReal);
SET_VECTOR_ELT(sModel,2,sfThreInt);
SET_VECTOR_ELT(sModel,3,sfScores);
SEXP sModelNames; PROTECT(sModelNames=NEW_CHARACTER(4));
SET_STRING_ELT(sModelNames,0,mkChar("splitAttIdxs"));
SET_STRING_ELT(sModelNames,1,mkChar("threReal"));
SET_STRING_ELT(sModelNames,2,mkChar("threInteger"));
SET_STRING_ELT(sModelNames,3,mkChar("scores"));
setAttrib(sModel,R_NamesSymbol,sModelNames);
SET_VECTOR_ELT(sAns,0,sModel);
UNPROTECT(6);
//UPs: sModelNames, sModel, sfThreInt, sfThreReal, sfSplitAtts, sfScores
//Left: sAns
}else{
SET_VECTOR_ELT(sAns,0,R_NilValue);
}
//Currently it always happens
if(M->oobPreds){
//Build score matrix for R, with NAs for object which were never OOB
SEXP sOobScores; PROTECT(sOobScores=allocVector(REALSXP,(Q.numClasses)*nObj));
SEXP sOobDim; PROTECT(sOobDim=allocVector(INTSXP,2));
INTEGER(sOobDim)[0]=Q.numClasses;
INTEGER(sOobDim)[1]=nObj;
double *tmp=REAL(sOobScores);
for(uint e=0;e<nObj;e++)
if(M->oobOutOfBagC[e])
for(uint ee=0;ee<Q.numClasses;ee++)
tmp[e*Q.numClasses+ee]=M->oobPreds[e*Q.numClasses+ee];
else
for(uint ee=0;ee<Q.numClasses;ee++)
tmp[e*Q.numClasses+ee]=NA_REAL;
setAttrib(sOobScores,R_DimSymbol,sOobDim);
SET_VECTOR_ELT(sAns,1,sOobScores);
UNPROTECT(2);
//UPs: sOobScores, sOobDim
//Left: sAns
if(!multi){
//Do actual voting on this matrix; push NA for never-oobs and
//random-of-max for ties.
SEXP sOobPreds; PROTECT(sOobPreds=allocVector(INTSXP,nObj));
sint *winningClass=INTEGER(sOobPreds);
for(uint e=0;e<nObj;e++)
if(M->oobOutOfBagC[e]){
winningClass[e]=whichMaxTieAware(&(M->oobPreds[e*Q.numClasses]),Q.numClasses,_R);
} else winningClass[e]=NA_INTEGER;
SET_VECTOR_ELT(sAns,4,sOobPreds);
UNPROTECT(1);
//UPs: sOobPreds
//Left: sAns
}else{
SET_VECTOR_ELT(sAns,4,R_NilValue);
}
}else{
SET_VECTOR_ELT(sAns,1,R_NilValue);
SET_VECTOR_ELT(sAns,4,R_NilValue);
}
if(M->oobErr){
SEXP sOobErr; PROTECT(sOobErr=allocVector(REALSXP,(Q.numFerns)));
double *tmp=REAL(sOobErr);
for(uint e=0;e<(Q.numFerns);e++)
tmp[e]=M->oobErr[e];
SET_VECTOR_ELT(sAns,2,sOobErr);
UNPROTECT(1);
//UPs: sOobErr
//Left: sAns
}else{
SET_VECTOR_ELT(sAns,2,R_NilValue);
}
if(M->imp){
SEXP sImp;
if(Q.calcImp==1){
PROTECT(sImp=allocVector(REALSXP,nAtt*2));
double *tmp=REAL(sImp);
for(uint e=0;e<nAtt;e++)
tmp[e]=M->imp[e];
for(uint e=0;e<nAtt;e++)
tmp[e+nAtt]=M->try[e];
}else{
PROTECT(sImp=allocVector(REALSXP,nAtt*3));
double *tmp=REAL(sImp);
for(uint e=0;e<nAtt;e++)
tmp[e]=M->imp[e];
for(uint e=0;e<nAtt;e++)
tmp[e+nAtt]=M->shimp[e];
for(uint e=0;e<nAtt;e++)
tmp[e+nAtt*2]=M->try[e];
}
SET_VECTOR_ELT(sAns,3,sImp);
UNPROTECT(1);
//UPs: sImp, one or another
//Left: sAns
}else{
// <TAG attr1="value1" attr2='value2' attr3=value3 >
// </TAG>
// or
// <TAG />
// ^- return pointer
//========================================================
// Desc : load xml plain text
// Param : pszXml - plain xml text
// pi = parser information
// Return : advanced std::string pointer
//========================================================
char* _tagXMLNode::load( const char* pszXml, LPPARSEINFO pi /*= &piDefault*/ )
{
char* xml = (char*)pszXml;
// initilize
parent = NULL;
childs.clear();
attrs.clear();
xml = _tcschr( xml, chXMLTagOpen );
if( xml == NULL )
return xml;
// Close Tag
if( *(xml+1) == chXMLTagPre ) // </Close
return xml;
// XML Node Tag Name Open
xml++;
char* pTagEnd = _tcspbrk( xml, " />" );
_Setstring( xml, pTagEnd, &name );
xml = pTagEnd;
// Generate XML Attributte List
if( xml = loadAttributes( xml, pi ) )
{
// alone tag <TAG ... />
if( *xml == chXMLTagPre )
{
xml++;
if( *xml == chXMLTagClose )
// wel-formed tag
return ++xml;
else
{
// error: <TAG ... / >
if( pi->erorr_occur == false )
{
pi->erorr_occur = true;
pi->error_pointer = xml;
pi->error_code = PIE_ALONE_NOT_CLOSED;
pi->error_string = "Element must be closed.";
}
// not wel-formed tag
return xml;
}
}
else
// open/close tag <TAG ..> ... </TAG>
// ^- current pointer
{
// insert if no text value
if( this->value.empty() )
{
// Text Value
char* pEnd = _tcsechr( ++xml, chXMLTagOpen, chXMLEscape );
if( pEnd == NULL )
{
if( pi->erorr_occur == false )
{
pi->erorr_occur = true;
pi->error_pointer = xml;
pi->error_code = PIE_NOT_CLOSED;
pi->error_string = "%s must be closed with </%s>", name;
pi->error_string += name;
}
// error cos not exist CloseTag </TAG>
return xml;
}
bool trim = pi->trim_value;
_Setstring( xml, pEnd, &value, trim, chXMLEscape );
xml = pEnd;
// TEXTVALUE reference
if( pi->entity_value && pi->entitys )
value = pi->entitys->ref2Entity(value.c_str());
}
// generate child nodes
while( xml && *xml )
{
LPXNode node = new XNode;
node->parent = this;
xml = node->load( xml,pi );
if( node->name.empty() == FALSE )
{
std::transform( node->name.begin(), node->name.end(), node->name.begin(), static_cast<int(*)(int)>(::tolower) );
//node->name.MakeLower();
childs.push_back( node );
}
else
{
delete node;
}
// open/close tag <TAG ..> ... </TAG>
// ^- current pointer
// CloseTag case
if( xml && *xml && *(xml+1) && *xml == chXMLTagOpen && *(xml+1) == chXMLTagPre )
{
// </Close>
xml+=2; // C
if( xml = _tcsskip( xml ) )
{
std::string closename;
char* pEnd = _tcspbrk( xml, " >" );
if( pEnd == NULL )
{
if( pi->erorr_occur == false )
{
pi->erorr_occur = true;
pi->error_pointer = xml;
pi->error_code = PIE_NOT_CLOSED;
pi->error_string = "it must be closed with";
pi->error_string += name;
}
// error
return xml;
}
_Setstring( xml, pEnd, &closename );
if( closename == this->name )
{
// wel-formed open/close
xml = pEnd+1;
// return '>' or ' ' after pointer
return xml;
}
else
{
xml = pEnd+1;
// not welformed open/close
if( pi->erorr_occur == false )
{
pi->erorr_occur = true;
pi->error_pointer = xml;
pi->error_code = PIE_NOT_NESTED;
pi->error_string = name + "..." + closename + " is not wel-formed.";
}
return xml;
}
}
}
else // Alone child Tag Loaded
{
if( xml && this->value.empty() && *xml !=chXMLTagOpen )
{
// Text Value
char* pEnd = _tcsechr( xml, chXMLTagOpen, chXMLEscape );
if( pEnd == NULL )
{
// error cos not exist CloseTag </TAG>
if( pi->erorr_occur == false )
{
pi->erorr_occur = true;
pi->error_pointer = xml;
pi->error_code = PIE_NOT_CLOSED;
pi->error_string = "it must be closed with"+ name;
}
return xml;
}
bool trim = pi->trim_value;
_Setstring( xml, pEnd, &value, trim, chXMLEscape );
xml = pEnd;
//TEXTVALUE
if( pi->entity_value && pi->entitys )
value = pi->entitys->ref2Entity(value.c_str());
}
}
}
}
}
return xml;
}
int ClassFile::loadClass(std::string classFileName)
{
std::ifstream file;
int length;
char * p;
file.open(classFileName.c_str());
if(file.is_open())
{
file.seekg(0,std::ios::end);
length = file.tellg();
file.seekg(0, std::ios::beg);
p = new char[length];
file.read(p, length);
file.close();
}
else
{
std::cout << "File (" << classFileName << ") load failed!" << std::endl;
throw 25;
}
magic = getu4(p);
p += 4;
if(magic != 0xCAFEBABE)
{
std::cout << "Magic constant is not right!:" << std::endl;
return 1;
}
minor_version = getu2(p);
p += 2;
major_version = getu2(p);
p += 2;
constant_pool_count = getu2(p);
p += 2;
if(constant_pool_count > 0)
{
loadConstants(p);
}
access_flags = getu2(p);
p += 2;
this_class = getu2(p);
p += 2;
super_class = getu2(p);
p += 2;
interfaces_count = getu2(p);
p += 2;
if(interfaces_count > 0)
{
loadInterfaces(p);
}
fields_count = getu2(p);
p += 2;
if(fields_count > 0)
{
loadFields(p);
}
methods_count = getu2(p);
p += 2;
if(methods_count > 0)
{
loadMethods(p);
}
attributes_count = getu2(p);
p += 2;
if(attributes_count > 0)
{
loadAttributes(p);
}
return 0;
}
