// Prints an INT value to the screen
void integerprint(char x, char y, int color, int background, int integer, char size) {
unsigned char tenthousands = 0;
unsigned char thousands = 0;
unsigned char hundreds = 0;
unsigned char tens = 0;
unsigned char ones = 0;
if (integer >= 10000) {
tenthousands = integer / 10000;
ASCII(x, y, color, background, tenthousands + 48, size);
}
if (integer >= 1000) {
thousands = ((integer - tenthousands * 10000)) / 1000;
x += 6;
ASCII(x, y, color, background, thousands + 48, size);
}
if (integer >= 100) {
hundreds = (((integer - tenthousands * 10000) - thousands * 1000) - 1) / 100;
x += 6;
ASCII(x, y, color, background, hundreds + 48, size);
}
if (integer >= 10) {
tens = (integer % 100) / 10;
x += 6;
ASCII(x, y, color, background, tens + 48, size);
}
ones = integer % 10;
x += 6;
ASCII(x, y, color, background, ones + 48, size);
}
AbstractObjectPtr
ObjectFactory::createObject(
const QString &aName,
const Position aPosition,
const qreal aWidth,
const qreal anHeight)
{
const ObjectFactory *myFactoryPtr = theFactoryListPtr->getFactoryPtr(aName);
DEBUG5("ObjectFactory::createObject(\"%s\") Factory=%p", ASCII(aName), myFactoryPtr);
if (myFactoryPtr == nullptr) {
DEBUG1("There is no factory for Object type '%s'", ASCII(aName));
return nullptr;
}
AbstractObject *myObjectPtr = myFactoryPtr->createObject();
assert (myObjectPtr != nullptr);
AbstractObjectPtr mySharedOPtr = AbstractObjectPtr(myObjectPtr);
myObjectPtr->theThisPtr = mySharedOPtr;
DEBUG5(" object created = %p, i18n name = '%s'", myObjectPtr, ASCII(myObjectPtr->getName()));
assert (aName.contains(" ") == false);
myObjectPtr->theInternalName = aName;
myObjectPtr->theCenter = aPosition;
if (aWidth != 1.0)
myObjectPtr->theWidth = aWidth;
if (anHeight != 1.0)
myObjectPtr->theHeight = anHeight;
// finally, get rid of the actual pointer and return the shared_ptr
assert (nullptr != mySharedOPtr);
return mySharedOPtr;
}
void Singleton::Translator::setLanguageGettext(const QString &aLocale)
{
bindtextdomain("tbe_levels", ASCII(theBaseTbeQtLocation));
textdomain( "tbe_levels");
// because putenv 'eats' the memory, strdup myBuffer before putenv'ing it
char myBuffer[255];
snprintf(myBuffer, 254, "LANGUAGE=%s", ASCII(aLocale));
putenv(strdup(myBuffer));
}
void PropertyList::list(void) const
{
DEBUG1("DEBUGGING: Requested listing of properties for object");
PropertyMap::const_iterator myI = theProperties.begin();
while (myI != theProperties.end()) {
char myBuffer[256];
strncpy (myBuffer, ASCII(myI.key()), 255);
DEBUG1(" '%s' = '%s'", myBuffer, ASCII(myI.value()));
++myI;
}
}
Hint *
HintSerializer::createObjectFromDom(const QDomNode &q)
{
QString myValue;
/// simple sanity check first...
if (q.nodeName() != theHintString) {
DEBUG2("createHintFromDom: expected <%s> but got <%s>", ASCII(theHintString), ASCII(q.nodeName()));
return nullptr;
}
Hint *myHPtr = new Hint();
// the nodemap contains all the attributes...
QDomNamedNodeMap myNodeMap = q.attributes();
for (int i = 0; i < myNodeMap.length(); i++) {
QString myAName = myNodeMap.item(i).nodeName();
QString myAValue = myNodeMap.item(i).nodeValue();
DEBUG5(" hint attribute: name %s", ASCII(myAName));
DEBUG5(" hint attribute: value %s", ASCII(myAValue));
if (theNumberString == myAName) {
myHPtr->theHintIndex = myAValue.toInt();
continue;
}
if (theObjectString == myAName) {
myHPtr->theObjectName = myAValue;
continue;
}
myHPtr->theParams.setProperty(myAName, myAValue);
}
// sanity checks:
if (myHPtr->theHintIndex == 0 || myHPtr->theObjectName == "-") {
DEBUG2("Hint parsing failed: mandatory field(s) missing");
goto not_good;
}
if (myHPtr->theParams.getPropertyCount() == 0) {
DEBUG2("Hint parsing failed: no parameter fields, that's just wrong");
goto not_good;
}
DEBUG4("createHintFromDom %d for '%s' successful", myHPtr->theHintIndex,
ASCII(myHPtr->theObjectName));
return myHPtr;
not_good:
delete myHPtr;
return nullptr;
}
void GameState::onEntry ( QEvent *event )
{
DEBUG4("GameControls-GameState %s onEntry!", ASCII(theName));
QState::onEntry(event);
isActive = true;
emit activated(this);
}
void print_array_dual (const unsigned char* array, int size)
{
// prints contents of an array
int idx;
int block;
#define NBLOCKS 4
size /= sizeof(u_int32_t);
for (block = 0; block < size; block += NBLOCKS)
{
char ascii4[6];
char ascii[128] = { 0, };
for (idx = block; idx < block + NBLOCKS; idx++)
{
#define H(v) ((unsigned char)(v))
// reads 32 bits word numbered idx and converts it to host endian format if necessary
// (assuming gba/arm's endianness is little-endian like network's convention)
u_int32_t v;
if (idx < size)
v = ntoh32(((u_int32_t*)array)[idx]);
else
v = 0xffffffff;
// print big endian first
print("%02x %02x %02x %02x - ", H(v), H(v>>8), H(v>>16), H(v>>24));
sprintf(ascii4, "%c%c%c%c ", ASCII(v), ASCII(v>>8), ASCII(v>>16), ASCII(v>>24));
strcat(ascii, ascii4);
}
print("%s\n", ascii);
}
}
bool Singleton::Translator::setLanguage(const QString &aLocale)
{
// ***
// *** Only use the part up to the first space
// ***
QString myLocale = aLocale.section(' ', 0, 0);
DEBUG2("Singleton::Translator::setLanguage for locale '%s'", ASCII(myLocale));
// ***
// *** For strings from TBE
// ***
if (!attemptTbeQtTranslatorLoad("", myLocale))
if (!attemptTbeQtTranslatorLoad("./", myLocale))
attemptTbeQtTranslatorLoad(I18N_DIRECTORY + "/", myLocale);
if (theTbeQtTranslator.isEmpty()) {
DEBUG1("NOTE: translator for TBE is empty");
} else
QCoreApplication::instance()->installTranslator(&theTbeQtTranslator);
// ***
// *** For strings from Qt itself
// ***
setLanguageQtIself(myLocale);
// ***
// *** For strings from our XML Levels (gettext):
// ***
setLanguageGettext(myLocale);
// We're going through all the motions, but the only thing that we count
// is whether the UI got translated...
return !theTbeQtTranslator.isEmpty();
}
/**********************************************************************
* _i7k_gum_chksum
*
* transfer integer chksum value to two bytes ASCII
* then gum it with CR (0x0d) to the given command string
*
* Arguments:
* cbuf the size of buffer must > strlen(cmd)+4
* cmd command string with ASCIIZ format
*
* Returned: a point to cbuf
*
**********************************************************************/
char *_i7k_gum_chksum(void *cbuf, const char *cmd)
{
char cL, cH;
char *p;
const char *q;
unsigned int chksum;
p = cbuf;
q = cmd;
chksum = 0;
while ((*q != 0) && (*q != ASCII_CR) && (*q != ASCII_LF)) { /* copy
* string */
chksum += *q;
*p++ = *q++;
}
PDEBUG("_i7k_gum_chksum: check-sum = 0x%x\n", chksum);
cL = ASCII(chksum & 0xf);
cH = ASCII((chksum >> 4) & 0xf);
*p++ = cH;
*p++ = cL;
*p++ = ASCII_CR;
*p = 0;
return (cbuf);
}
/**********************************************************************
* _i7k_chksum
*
* test the check-sum of i7k command or received string
* string must has tail of ASCII_CR or ASCII_LF, or 0
*
* Arguments:
* str string to test check-sum
*
* Returned: 0 ok, -1 check-sum error!
*
**********************************************************************/
int _i7k_chksum(const char *str)
{
char cL, cH;
const char *p;
unsigned int chksum;
p = str;
chksum = 0;
while ((*p != ASCII_LF) && (*p != ASCII_CR) && (*p != 0)) {
chksum += *p++;
}
chksum -= *(--p);
chksum -= *(--p);
PDEBUG("_i7k_chksum: check-sum = 0x%x\n", chksum);
cL = ASCII(chksum & 0xf);
cH = ASCII((chksum >> 4) & 0xf);
if (cH != *p++) {
return -1;
}
if (cL != *p) {
return -1;
}
return (0);
}
int main()
{
char x;
int y, z,i=0;
while (i=!0){
scanf("\n%c", &x);
ASCII(x,y,z);
}
}
static String get_hash (const String & server_id, const Vector<Byte> & secret, const Vector<Byte> & public_key) {
MCPP::SHA1 hash;
hash.Update(ASCII().Encode(server_id));
hash.Update(secret);
hash.Update(public_key);
return hash.HexDigest();
}
// Each line with size 1 should be around 8 pixels apart, font will wrap around
// the screen if it's too long
void printrs(char x, char y, int color, int background, char* message, char size) {
while (*message) {
ASCII(x, y, color, background, *message++, size);
x += 6 * size;
if (x > 120) {
x = 0;
y += 8 * size;
}
}
}
void
ObjectFactory::announceObjectType(const QString &anObjectTypeName, ObjectFactory *aThisPtr)
{
DEBUG4("ObjectFactory::announceObjectType(\"%s\", %p)",
ASCII(anObjectTypeName), aThisPtr);
if (theFactoryListPtr == nullptr)
theFactoryListPtr = new FactoryList();
theFactoryListPtr->insert(anObjectTypeName, aThisPtr);
aThisPtr->theFactoryName = anObjectTypeName;
}
void EditPropertyUndoCommand::undo(void)
{
DEBUG4("EditPropertyUndoCommand::undo for '%s'", ASCII(text()));
AbstractObjectPtr myAOPtr = theViewObjPtr->getAbstractObjectPtr();
if (!theKey.isNull())
myAOPtr->theProps.setProperty(theKey, theOldValue);
else
myAOPtr->theID = theOldID;
AbstractUndoCommand::undo();
}
// Each line with size 1 should be around 8 pixels apart, font will wrap around
// the screen if it's too long
void prints(char x, char y, int color, int background, const char messageOld[], char size) {
const far rom char* message = (const far rom char*) messageOld;
while (*message) {
ASCII(x, y, color, background, *message++, size);
x += 6 * size;
if (x > 120) {
x = 0;
y += 8 * size;
}
}
}
bool Singleton::Translator::init()
{
DEBUG1ENTRY;
//** Strings in source code or XML are UTF-8, make sure Qt understands
theTextCodecPtr = QTextCodec::codecForName("UTF-8");
QTextCodec::setCodecForLocale(theTextCodecPtr);
// retrieve the locale and set it
QString myCurrentLocaleName = QLocale::system().name();
DEBUG1("going to set locale '%s'", ASCII(myCurrentLocaleName));
return setLanguage(myCurrentLocaleName);
}
void EditPropertyUndoCommand::redo(void)
{
DEBUG4("EditPropertyUndoCommand::redo for '%s'", ASCII(text()));
AbstractObjectPtr myAOPtr = theViewObjPtr->getAbstractObjectPtr();
if (!theKey.isNull())
myAOPtr->theProps.setProperty(theKey, theNewValue);
else
myAOPtr->theID = theNewID;
// our parent also has to do some things...
AbstractUndoCommand::redo();
}
ViewResizeRotateMoveUndo::~ViewResizeRotateMoveUndo()
{
// check if we're being deleted because the parent ends...
if (nullptr==ViewWorldItem::me())
return;
// if not, we're probably up for an undo commit...
if (theUndoPtr) {
DEBUG3("ViewResizeRotateMoveUndo::~ViewResizeRotateMoveUndo(), but still unfinished undo present.");
DEBUG3(" this is common: it likely didn't get completed yet.")
DEBUG3(" theUndoPtr: %p, name: '%s'.", theUndoPtr, ASCII(theUndoPtr->text()));
commitChanges();
}
}
bool Singleton::Translator::attemptTbeQtTranslatorLoad(
const QString &aPath,
const QString &aLocale)
{
QString myLocation = aPath + "tbe_" + aLocale;
DEBUG3("Attemp: load translator from %s", ASCII(myLocation));
if (theTbeQtTranslator.load(myLocation)) {
DEBUG3(" ... success");
theBaseTbeQtLocation = aPath;
return true;
} else {
DEBUG3(" ... fail");
return false;
}
}
bool SaveLevelInfo::performFileExists(const QString &aFileName)
{
if (isUserOKOverwritingFile == true)
return true;
if (QFile::exists(aFileName)) {
DEBUG5("File '%s' already exists!", ASCII(aFileName) );
if (Popup::YesNoQuestion(tr("A File with name '%1' file already exists. Overwrite?\n").arg(
aFileName),
this) == false)
return false;
isUserOKOverwritingFile = true;
}
return true;
}
SaveLevelInfo::SaveLevelInfo(Level *aLevelPtr, QWidget *parent)
: QDialog(parent), theLevelPtr(aLevelPtr)
{
isUserOKOverwritingFile = false;
ui.setupUi(this);
ui.theFileNameField ->setText(theLevelPtr->getLevelFileName());
ui.theAuthorNameField ->setText(theLevelPtr->theLevelAuthor);
ui.theLevelDescriptionField->setText(theLevelPtr->theLevelDescription);
ui.theLicenseField ->setText(theLevelPtr->theLevelLicense);
ui.theTitleField ->setText(theLevelPtr->theLevelName);
QDate myDate = QDate::fromString(theLevelPtr->theLevelDate);
if (myDate.isValid())
ui.theDateEdit->setDate(myDate);
else {
DEBUG5("SaveLevelInfo::SaveLevelInfo - Date '%s' is not understood, setting to current date",
ASCII(theLevelPtr->theLevelDate));
ui.theDateEdit->setDate(QDate::currentDate());
}
connect(ui.theFileNameField, SIGNAL(textEdited(const QString &)), this, SLOT(fileNameChanged()));
}
static void add(char *s1, char *s2)
{
char *a, *b, *c;
int la, lb, len;
int i, j;
int carry;
int add;
a = BIGGEST(s1, s2);
b = SMALLEST(s1, s2);
la = strlen(a);
lb = strlen(b);
len = la + 1;
if (!(c = memset(malloc((len + 1) * sizeof(char)), '0', len)))
return ;
c[len] = 0;
for (i = la - 1, j = lb - 1, carry = 0; i >= IS_NEG(a); --i, --j)
{
if (IS_NEG(a) == IS_NEG(b))
{
add = ALIGN(a, i) + ALIGN(b, j) + carry;
carry = add / 10;
}
else
{
add = ALIGN(a, i) - ALIGN(b, j) - carry;
carry = (add < 0);
add = POS(add);
}
c[i + 1] = ASCII(POS(add % 10));
}
if (IS_NEG(a) && (a != SMALLEST(b, a)
|| IS_NEG(b)))
printf("-");
print_nb(c);
free(c);
}
void processKeyboard(GlobalState* globalData, char* name, int size) {
static short pos[] = {0, 0};
static short letters = 0;
if (globalData->newKeyboard == 1) {
globalData->newKeyboard = 0;
pos[0] = 0;
pos[1] = 0;
letters = 0;
} else {
switch (globalData->keyPress) {
case 0x08:
prints(3 + 12 * pos[0], 10 * pos[1] + 23, WHITE, BLUE, " ", 1);
if (pos[1] < 2) {
pos[1]++;
}
prints(3 + 12 * pos[0], 10 * pos[1] + 23, WHITE, BLUE, ">", 1);
break;
case 0x02:
prints(3 + 12 * pos[0], 10 * pos[1] + 23, WHITE, BLUE, " ", 1);
if (pos[1] > 0) {
pos[1]--;
}
prints(3 + 12 * pos[0], 10 * pos[1] + 23, WHITE, BLUE, ">", 1);
break;
case 0x04:
prints(3 + 12 * pos[0], 10 * pos[1] + 23, WHITE, BLUE, " ", 1);
if (pos[0] > 0) {
pos[0]--;
}
prints(3 + 12 * pos[0], 10 * pos[1] + 23, WHITE, BLUE, ">", 1);
break;
case 0x06:
prints(3 + 12 * pos[0], 10 * pos[1] + 23, WHITE, BLUE, " ", 1);
if (pos[0] < 9) {
pos[0]++;
}
prints(3 + 12 * pos[0], 10 * pos[1] + 23, WHITE, BLUE, ">", 1);
break;
case 0x0D:
if (letters < size - 1) {
name[letters] = (char) (65 + pos[0] + 10 * pos[1]);
name[letters + 1] = '\0';
ASCII(6 + 12 * letters, 8, WHITE, BLUE, name[letters], 1);
letters = letters + 1;
if (letters == size - 1) {
prints(42 + 12 * 5, 0, WHITE, BLUE, "end", 1);
}
}
break;
case 0x0B:
if (letters > 0) {
if (letters == size - 1) {
prints(42 + 12 * 5, 0, WHITE, BLUE, " ", 1);
}
letters--;
ASCII(6 + 12 * letters, 8, WHITE, BLUE, '_', 1);
name[letters] = '\0';
}
break;
case 0x0F:
globalData->doneKeyboard = 1;
globalData->newKeyboard = 1;
break;
}
}
}
void PoissonReconstruction::PoissonRecon(int argc , char* argv[], const MagicDGP::Point3DSet* pPC, std::vector< PlyValueVertex< float > >& vertices, std::vector< std::vector< int > >& polygons)
{
cmdLineString
In( "in" ) ,
Out( "out" ) ,
VoxelGrid( "voxel" ) ,
XForm( "xForm" );
cmdLineReadable
Performance( "performance" ) ,
ShowResidual( "showResidual" ) ,
NoComments( "noComments" ) ,
PolygonMesh( "polygonMesh" ) ,
Confidence( "confidence" ) ,
NonManifold( "nonManifold" ) ,
ASCII( "ascii" ) ,
Density( "density" ) ,
Verbose( "verbose" );
cmdLineInt
Depth( "depth" , 8 ) ,
SolverDivide( "solverDivide" , 8 ) ,
IsoDivide( "isoDivide" , 8 ) ,
KernelDepth( "kernelDepth" ) ,
AdaptiveExponent( "adaptiveExp" , 1 ) ,
MinIters( "minIters" , 24 ) ,
FixedIters( "iters" , -1 ) ,
VoxelDepth( "voxelDepth" , -1 ) ,
MinDepth( "minDepth" , 5 ) ,
MaxSolveDepth( "maxSolveDepth" ) ,
BoundaryType( "boundary" , 1 ) ,
Threads( "threads" , omp_get_num_procs() );
cmdLineFloat
SamplesPerNode( "samplesPerNode" , 1.f ) ,
Scale( "scale" , 1.1f ) ,
SolverAccuracy( "accuracy" , float(1e-3) ) ,
PointWeight( "pointWeight" , 4.f );
cmdLineReadable* params[] =
{
&In , &Depth , &Out , &XForm ,
&SolverDivide , &IsoDivide , &Scale , &Verbose , &SolverAccuracy , &NoComments ,
&KernelDepth , &SamplesPerNode , &Confidence , &NonManifold , &PolygonMesh , &ASCII , &ShowResidual , &MinIters , &FixedIters , &VoxelDepth ,
&PointWeight , &VoxelGrid , &Threads , &MinDepth , &MaxSolveDepth ,
&AdaptiveExponent , &BoundaryType ,
&Density
};
cmdLineParse( argc , argv , sizeof(params)/sizeof(cmdLineReadable*) , params , 1 );
/*if( Density.set )
return Execute< 2 , PlyValueVertex< Real > , true >(argc , argv, pPC);
else
return Execute< 2 , PlyVertex< Real > , false >(argc , argv, pPC);*/
//Execute
int i;
int paramNum = sizeof(params)/sizeof(cmdLineReadable*);
int commentNum=0;
char **comments;
comments = new char*[paramNum + 7];
for( i=0 ; i<paramNum+7 ; i++ ) comments[i] = new char[1024];
//if( Verbose.set ) echoStdout=1;
XForm4x4< Real > xForm , iXForm;
if( XForm.set )
{
FILE* fp = fopen( XForm.value , "r" );
if( !fp )
{
fprintf( stderr , "[WARNING] Could not read x-form from: %s\n" , XForm.value );
xForm = XForm4x4< Real >::Identity();
}
else
{
for( int i=0 ; i<4 ; i++ ) for( int j=0 ; j<4 ; j++ ) fscanf( fp , " %f " , &xForm( i , j ) );
fclose( fp );
}
}
else xForm = XForm4x4< Real >::Identity();
iXForm = xForm.inverse();
//DumpOutput2( comments[commentNum++] , "Running Screened Poisson Reconstruction (Version 5.0)\n" , Degree );
//char str[1024];
//for( int i=0 ; i<paramNum ; i++ )
// if( params[i]->set )
// {
// params[i]->writeValue( str );
// if( strlen( str ) ) DumpOutput2( comments[commentNum++] , "\t--%s %s\n" , params[i]->name , str );
// else DumpOutput2( comments[commentNum++] , "\t--%s\n" , params[i]->name );
// }
double t;
double tt=Time();
Real isoValue = 0;
//Octree< Degree , OutputDensity > tree;
Octree< 2 , true > tree;
tree.threads = Threads.value;
//if( !In.set )
//{
// ShowUsage(argv[0]);
// return 0;
//}
if( !MaxSolveDepth.set ) MaxSolveDepth.value = Depth.value;
if( SolverDivide.value<MinDepth.value )
{
fprintf( stderr , "[WARNING] %s must be at least as large as %s: %d>=%d\n" , SolverDivide.name , MinDepth.name , SolverDivide.value , MinDepth.value );
SolverDivide.value = MinDepth.value;
}
if( IsoDivide.value<MinDepth.value )
{
fprintf( stderr , "[WARNING] %s must be at least as large as %s: %d>=%d\n" , IsoDivide.name , MinDepth.name , IsoDivide.value , IsoDivide.value );
IsoDivide.value = MinDepth.value;
}
OctNode< TreeNodeData< true > , Real >::SetAllocator( MEMORY_ALLOCATOR_BLOCK_SIZE );
t=Time();
int kernelDepth = KernelDepth.set ? KernelDepth.value : Depth.value-2;
tree.setBSplineData( Depth.value , BoundaryType.value );
//if( kernelDepth>Depth.value )
//{
// fprintf( stderr,"[ERROR] %s can't be greater than %s: %d <= %d\n" , KernelDepth.name , Depth.name , KernelDepth.value , Depth.value );
// return EXIT_FAILURE;
//}
//
int pointNumber = pPC->GetPointNumber();
std::vector<float> posList(pointNumber * 3);
std::vector<float> norList(pointNumber * 3);
for (int pIndex = 0; pIndex < pointNumber; pIndex++)
{
posList.at(3 * pIndex + 0) = pPC->GetPoint(pIndex)->GetPosition()[0];
posList.at(3 * pIndex + 1) = pPC->GetPoint(pIndex)->GetPosition()[1];
posList.at(3 * pIndex + 2) = pPC->GetPoint(pIndex)->GetPosition()[2];
norList.at(3 * pIndex + 0) = pPC->GetPoint(pIndex)->GetNormal()[0];
norList.at(3 * pIndex + 1) = pPC->GetPoint(pIndex)->GetNormal()[1];
norList.at(3 * pIndex + 2) = pPC->GetPoint(pIndex)->GetNormal()[2];
}
//
double maxMemoryUsage;
t=Time() , tree.maxMemoryUsage=0;
//int pointCount = tree.setTree( In.value , Depth.value , MinDepth.value , kernelDepth , Real(SamplesPerNode.value) , Scale.value , Confidence.set , PointWeight.value , AdaptiveExponent.value , xForm );
int pointCount = tree.setTree( posList, norList, Depth.value , MinDepth.value , kernelDepth , Real(SamplesPerNode.value) , Scale.value , Confidence.set , PointWeight.value , AdaptiveExponent.value , xForm );
tree.ClipTree();
tree.finalize( IsoDivide.value );
/*DumpOutput2( comments[commentNum++] , "# Tree set in: %9.1f (s), %9.1f (MB)\n" , Time()-t , tree.maxMemoryUsage );
DumpOutput( "Input Points: %d\n" , pointCount );
DumpOutput( "Leaves/Nodes: %d/%d\n" , tree.tree.leaves() , tree.tree.nodes() );
DumpOutput( "Memory Usage: %.3f MB\n" , float( MemoryInfo::Usage() )/(1<<20) );*/
maxMemoryUsage = tree.maxMemoryUsage;
t=Time() , tree.maxMemoryUsage=0;
tree.SetLaplacianConstraints();
/*DumpOutput2( comments[commentNum++] , "# Constraints set in: %9.1f (s), %9.1f (MB)\n" , Time()-t , tree.maxMemoryUsage );
DumpOutput( "Memory Usage: %.3f MB\n" , float( MemoryInfo::Usage())/(1<<20) );*/
maxMemoryUsage = std::max< double >( maxMemoryUsage , tree.maxMemoryUsage );
t=Time() , tree.maxMemoryUsage=0;
tree.LaplacianMatrixIteration( SolverDivide.value, ShowResidual.set , MinIters.value , SolverAccuracy.value , MaxSolveDepth.value , FixedIters.value );
/*DumpOutput2( comments[commentNum++] , "# Linear system solved in: %9.1f (s), %9.1f (MB)\n" , Time()-t , tree.maxMemoryUsage );
DumpOutput( "Memory Usage: %.3f MB\n" , float( MemoryInfo::Usage() )/(1<<20) );*/
maxMemoryUsage = std::max< double >( maxMemoryUsage , tree.maxMemoryUsage );
CoredFileMeshData< PlyValueVertex< Real > > mesh;
if( Verbose.set ) tree.maxMemoryUsage=0;
t=Time();
isoValue = tree.GetIsoValue();
//DumpOutput( "Got average in: %f\n" , Time()-t );
//DumpOutput( "Iso-Value: %e\n" , isoValue );
if( VoxelGrid.set )
{
double t = Time();
FILE* fp = fopen( VoxelGrid.value , "wb" );
if( !fp ) fprintf( stderr , "Failed to open voxel file for writing: %s\n" , VoxelGrid.value );
else
{
int res;
Pointer( Real ) values = tree.GetSolutionGrid( res , isoValue , VoxelDepth.value );
fwrite( &res , sizeof(int) , 1 , fp );
if( sizeof(Real)==sizeof(float) ) fwrite( values , sizeof(float) , res*res*res , fp );
else
{
float *fValues = new float[res*res*res];
for( int i=0 ; i<res*res*res ; i++ ) fValues[i] = float( values[i] );
fwrite( fValues , sizeof(float) , res*res*res , fp );
delete[] fValues;
}
fclose( fp );
DeletePointer( values );
}
//DumpOutput( "Got voxel grid in: %f\n" , Time()-t );
}
if( Out.set )
{
t = Time() , tree.maxMemoryUsage = 0;
tree.GetMCIsoTriangles( isoValue , IsoDivide.value , &mesh , 0 , 1 , !NonManifold.set , PolygonMesh.set );
//if( PolygonMesh.set ) DumpOutput2( comments[commentNum++] , "# Got polygons in: %9.1f (s), %9.1f (MB)\n" , Time()-t , tree.maxMemoryUsage );
//else DumpOutput2( comments[commentNum++] , "# Got triangles in: %9.1f (s), %9.1f (MB)\n" , Time()-t , tree.maxMemoryUsage );
maxMemoryUsage = std::max< double >( maxMemoryUsage , tree.maxMemoryUsage );
//DumpOutput2( comments[commentNum++],"# Total Solve: %9.1f (s), %9.1f (MB)\n" , Time()-tt , maxMemoryUsage );
//if( NoComments.set )
//{
// if( ASCII.set ) PlyWritePolygons( Out.value , &mesh , PLY_ASCII , NULL , 0 , iXForm );
// else PlyWritePolygons( Out.value , &mesh , PLY_BINARY_NATIVE , NULL , 0 , iXForm );
//}
//else
//{
// if( ASCII.set ) PlyWritePolygons( Out.value , &mesh , PLY_ASCII , comments , commentNum , iXForm );
// else PlyWritePolygons( Out.value , &mesh , PLY_BINARY_NATIVE , comments , commentNum , iXForm );
//}
vertices.clear();
polygons.clear();
int incorePointNum = int( mesh.inCorePoints.size() );
int outofcorePointNum = mesh.outOfCorePointCount();
DebugLog << "incorePointNum: " << incorePointNum << std::endl;
DebugLog << "outofcorePointNum: " << outofcorePointNum << std::endl;
mesh.resetIterator();
for(int pIndex = 0 ; pIndex < incorePointNum ; pIndex++ )
{
PlyValueVertex< Real > vertex = iXForm * mesh.inCorePoints[pIndex];
vertices.push_back(vertex);
//ply_put_element(ply, (void *) &vertex);
}
for(int pIndex = 0; pIndex < outofcorePointNum; pIndex++ )
{
PlyValueVertex< Real > vertex;
mesh.nextOutOfCorePoint( vertex );
vertex = iXForm * ( vertex );
vertices.push_back(vertex);
//ply_put_element(ply, (void *) &vertex);
}
int polyNum = mesh.polygonCount();
DebugLog << "polyNum: " << polyNum << std::endl;
for (int pIndex = 0; pIndex < polyNum; pIndex++)
{
std::vector< CoredVertexIndex > coreIndex;
mesh.nextPolygon(coreIndex);
std::vector< int > pureIndex;
for (int ii = 0; ii < coreIndex.size(); ii++)
{
if (coreIndex.at(ii).inCore)
{
pureIndex.push_back(coreIndex.at(ii).idx);
}
else
{
pureIndex.push_back(coreIndex.at(ii).idx + incorePointNum);
}
}
if (coreIndex.size() != 3)
{
DebugLog << "Error: coreIndex.size: " << coreIndex.size() << std::endl;
}
polygons.push_back(pureIndex);
}
//just for test
/*DebugLog << "Export inter object" << std::endl;
std::ofstream fout("pc_inter.obj");
for (int pIndex = 0; pIndex < vertices.size(); pIndex++)
{
PlyValueVertex< float > vert = vertices.at(pIndex);
fout << "v " << vert.point[0] << " " << vert.point[1] << " " << vert.point[2] << std::endl;
}
for (int pIndex = 0; pIndex < polygons.size(); pIndex++)
{
fout << "f " << polygons.at(pIndex).at(0) + 1 << " " << polygons.at(pIndex).at(1) + 1 << " " << polygons.at(pIndex).at(2) + 1 << std::endl;
}
fout.close();*/
}
}
void main(void)
{
WDTCTL = WDTPW + WDTHOLD; // Stop the watchdog
__enable_interrupt(); // Enable general interrupts
Board_init(); // Configure's the F5529 EXP board's I/Os
// Initialize power/clocks for use with USB
SetVCore(3); // The USB module requires that VCore be set to highest setting, independent of MCLK freq
ClockUSB();
disk_initialize(0); // SD-cards must go through a setup sequence after powerup. This FatFs call does this.
USB_init(); // Initializes the USB API, and prepares the USB module to detect USB insertion/removal events
USB_setEnabledEvents(kUSB_allUsbEvents); // Enable all USB events
// The data interchange buffer (used when handling SCSI READ/WRITE) is declared by the application, and
// registered with the API using this function. This allows it to be assigned dynamically, giving
// the application more control over memory management.
USBMSC_registerBufInfo(&RW_dataBuf[0], NULL, sizeof(RW_dataBuf));
// The API maintains an instance of the USBMSC_RWbuf_Info structure. If double-buffering were used, it would
// maintain one for both the X and Y side. (This version of the API only supports single-buffering,
// so only one structure is maintained.) This is a shared resource between the API and application; the
// application must request the pointers.
RWbuf_info = USBMSC_fetchInfoStruct();
// USBMSC_updateMediaInfo() must be called prior to USB connection. We check if the card is present, and if so, pull its size
// and bytes per block.
// LUN0
mediaInfo.mediaPresent = 0x01; // The medium is present, because internal flash is non-removable.
mediaInfo.mediaChanged = 0x00; // It can't change, because it's in internal memory, which is always present.
mediaInfo.writeProtected = 0x00; // It's not write-protected
mediaInfo.lastBlockLba = 774; // 774 blocks in the volume. (This number is also found twice in the volume itself; see mscFseData.c. They should match.)
mediaInfo.bytesPerBlock = BYTES_PER_BLOCK; // 512 bytes per block. (This number is also found in the volume itself; see mscFseData.c. They should match.)
USBMSC_updateMediaInfo(0, &mediaInfo);
// LUN1
if(detectCard())
mediaInfo.mediaPresent = kUSBMSC_MEDIA_PRESENT;
else mediaInfo.mediaPresent = kUSBMSC_MEDIA_NOT_PRESENT;
mediaInfo.mediaChanged = 0x00;
mediaInfo.writeProtected = 0x00;
disk_ioctl(0,GET_SECTOR_COUNT,&mediaInfo.lastBlockLba); // Returns the number of blocks (sectors) in the media.
mediaInfo.bytesPerBlock = BYTES_PER_BLOCK; // Block size will always be 512
USBMSC_updateMediaInfo(1, &mediaInfo);
// At compile-time for this demo, there will be one file on the volume. The root directory and data cluster
// for this file need to be initialized.
//flashWrite_LBA(Root_Dir, (BYTE*)Root_Dir_init);
//flashWrite_LBA(Data559, (BYTE*)Data559_init);
// Configure Timer_A0 to prompt detection of the SD card every second
TA0CCTL0 = CCIE; // Enable interrupt
TA0CCR0 = 32768; // Clock will be 32kHz, so we set the int to occur when it counts to 32768
TA0CTL = TASSEL_1 + MC_1 + TACLR; // ACLK = 32kHz, up mode, clear TAR... go!
// If USB is already connected when the program starts up, then there won't be a USB_handleVbusOnEvent().
// So we need to check for it, and manually connect if the host is already present.
if (USB_connectionInfo() & kUSB_vbusPresent)
{
if (USB_enable() == kUSB_succeed)
{
USB_reset();
USB_connect();
}
}
while(1)
{
BYTE ReceiveError=0, SendError=0;
WORD count;
switch(USB_connectionState())
{
case ST_USB_DISCONNECTED:
__bis_SR_register(LPM3_bits + GIE); // Enter LPM3 until VBUS-on event
// Check if the reason we woke was a button press; and if so, log a new piece of data.
if(fS1ButtonEvent)
{
// Build string
char str[14] = "Data entry #0\n";
str[12] = logCnt++; // Number the entries 0 through....?
memcpy(RW_dataBuf, Data559, BYTES_PER_BLOCK); // Copy data block 559 from flash to RAM buffer
memcpy(&RW_dataBuf[DataCnt], str, sizeof(str)); // Write the new entry to the RAM buffer
flashWrite_LBA((PBYTE)Data559, RW_dataBuf); // Copy it back to flash
DataCnt += sizeof(str); // Increment the index past the new entry
if((DataCnt + sizeof(str)>= BYTES_PER_BLOCK)) // Roll index back to 0, if no more room in the block
DataCnt = 0;
fS1ButtonEvent = 0;
}
break;
case ST_USB_CONNECTED_NO_ENUM:
break;
case ST_ENUM_ACTIVE:
// Call USBMSC_poll() to initiate handling of any received SCSI commands. Disable interrupts
// during this function, to avoid conflicts arising from SCSI commands being received from the host
// AFTER decision to enter LPM is made, but BEFORE it's actually entered (in other words, avoid
// sleeping accidentally).
__disable_interrupt();
if((USBMSC_poll() == kUSBMSC_okToSleep) && (!bDetectCard))
{
__bis_SR_register(LPM0_bits + GIE); // Enable interrupts atomically with LPM0 entry
}
__enable_interrupt();
// If the API needs the application to process a buffer, it will keep the CPU awake by returning kUSBMSC_processBuffer
// from USBMSC_poll(). The application should then check the 'operation' field of all defined USBMSC_RWbuf_Info
// structure instances. If any of them is non-null, then an operation needs to be processed. A value of
// kUSBMSC_READ indicates the API is waiting for the application to fetch data from the storage volume, in response
// to a SCSI READ command from the USB host. After the application does this, it must indicate whether the
// operation succeeded, and then close the buffer operation by calling USBMSC_bufferProcessed().
while(RWbuf_info->operation == kUSBMSC_READ)
{
switch(RWbuf_info->lun)
{
case 0:
RWbuf_info->returnCode = Read_LBA(RWbuf_info->lba, RWbuf_info->bufferAddr, RWbuf_info->lbCount); // Fetch a block from the medium, using file system emulation
USBMSC_bufferProcessed(); // Close the buffer operation
break;
case 1:
read_LUN1();
break;
}
}
// Everything in this section is analogous to READs. Reference the comments above.
while(RWbuf_info->operation == kUSBMSC_WRITE)
{
switch(RWbuf_info->lun)
{
case 0:
RWbuf_info->returnCode = Write_LBA(RWbuf_info->lba, RWbuf_info->bufferAddr, RWbuf_info->lbCount); // Write the block to the medium, using file system emulation
USBMSC_bufferProcessed(); // Close the buffer operation
break;
case 1:
write_LUN1();
break;
}
}
// Every second, the Timer_A ISR sets this flag. The checking can't be done from within the timer ISR, because the
// checking enables interrupts, and this is not a recommended practice due to the risk of nested interrupts.
if(bDetectCard)
{
checkInsertionRemoval();
bDetectCard = 0x00; // Clear the flag, until the next timer ISR
}
if(bHID_DataReceived_event) //Message is received from HID application
{
bHID_DataReceived_event = FALSE; // Clear flag early -- just in case execution breaks below because of an error
count = hidReceiveDataInBuffer((BYTE*)dataBuffer,BUFFER_SIZE,HID0_INTFNUM);
strncat(wholeString," \r\nRx->",7);
strncat(wholeString,(char*)dataBuffer,count);
strncat(wholeString," \r\n ",4);
if(cdcSendDataInBackground((BYTE*)wholeString,strlen(wholeString),CDC0_INTFNUM,1)) // Send message to other CDC App
{
SendError = 0x01;
break;
}
memset(wholeString,0,MAX_STR_LENGTH); // Clear wholeString
}
if(bCDC_DataReceived_event) //Message is received from CDC application
{
bCDC_DataReceived_event = FALSE; // Clear flag early -- just in case execution breaks below because of an error
cdcReceiveDataInBuffer((BYTE*)wholeString,MAX_STR_LENGTH,CDC0_INTFNUM);
ASCII(wholeString);
if(hidSendDataInBackground((BYTE*)wholeString,strlen(wholeString),HID0_INTFNUM,1)) // Send message to HID App
{
SendError = 0x01; // Something went wrong -- exit
break;
}
memset(wholeString,0,MAX_STR_LENGTH); // Clear wholeString
}
break;
case ST_ENUM_SUSPENDED:
__bis_SR_register(LPM3_bits + GIE); // Enter LPM3, until a resume or VBUS-off event
break;
case ST_ENUM_IN_PROGRESS:
break;
case ST_ERROR:
break;
default:;
}
if(ReceiveError || SendError)
{
//TO DO: User can place code here to handle error
}
}
}
int isxdigit(int ch) { return ASCII(ch)? (type[ch] & XDIGIT): 0; }
int isupper(int ch) { return ASCII(ch)? (type[ch] & UPPER): 0; }
int isspace(int ch) { return ASCII(ch)? (type[ch] & SPACE): 0; }
int ispunct(int ch) { return ASCII(ch)? (type[ch] & PUNCT): 0; }