//-------------------------------------------
bool ofxAssimpModelLoader::loadModel(ofBuffer & buffer, bool optimize, const char * extension){
normalizeFactor = ofGetWidth() / 2.0;
// only ever give us triangles.
aiSetImportPropertyInteger(AI_CONFIG_PP_SBP_REMOVE, aiPrimitiveType_LINE | aiPrimitiveType_POINT );
aiSetImportPropertyInteger(AI_CONFIG_PP_PTV_NORMALIZE, true);
// aiProcess_FlipUVs is for VAR code. Not needed otherwise. Not sure why.
unsigned int flags = aiProcessPreset_TargetRealtime_MaxQuality | aiProcess_Triangulate | aiProcess_FlipUVs;
if(optimize) flags |= aiProcess_ImproveCacheLocality | aiProcess_OptimizeGraph |
aiProcess_OptimizeMeshes | aiProcess_JoinIdenticalVertices |
aiProcess_RemoveRedundantMaterials;
if(scene){
clear();
}
scene = aiImportFileFromMemory(buffer.getBinaryBuffer(), buffer.size(), flags, extension);
if(scene){
calculateDimensions();
loadGLResources();
if(getAnimationCount())
ofLog(OF_LOG_VERBOSE, "scene has animations");
else {
ofLog(OF_LOG_VERBOSE, "no animations");
}
return true;
}else{
ofLog(OF_LOG_ERROR,string("ofxAssimpModelLoader: ") + aiGetErrorString());
return false;
}
}
bool Scene::load(const ofBuffer& buffer, bool optimize, Handedness handness, const char* extension) {
unload();
unsigned int flags = aiProcessPreset_TargetRealtime_MaxQuality;
if (optimize) {
flags |= aiProcess_ImproveCacheLocality |
aiProcess_JoinIdenticalVertices |
aiProcess_RemoveRedundantMaterials;
}
if (handness == LEFT_HANDED) {
flags |= aiProcess_ConvertToLeftHanded;
}
scene = aiImportFileFromMemory(buffer.getBinaryBuffer(), buffer.size(),
flags, extension);
string err_str = aiGetErrorString();
if (!err_str.empty())
{
ofLogError("ofxAssimp::Scene::load") << err_str;
}
assert(scene);
setupResources();
setupNodes();
setupAnimations();
return true;
}
string ofxCrypto::base64_encode(ofBuffer &buffer) {
long max = buffer.size();
char *buf = buffer.getBinaryBuffer();
string str = string(buf,max);
return base64_encode(str);
}
//----------------------------------------------------
bool ofImage::loadImageFromMemory(const ofBuffer & buffer, ofPixels &pix){
int width, height, bpp;
bool bLoaded = false;
FIBITMAP * bmp = NULL;
FIMEMORY *hmem = NULL;
printf("loadImageFromMemory\n");
hmem = FreeImage_OpenMemory((unsigned char*)buffer.getBuffer(), buffer.size());
if (hmem == NULL){
ofLog(OF_LOG_ERROR,"couldn't create memory handle! \n");
return false;
}
//get the file type!
FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(hmem);
if( fif == -1 ){
ofLog(OF_LOG_ERROR,"unable to guess format", fif);
return false;
FreeImage_CloseMemory(hmem);
}
//make the image!!
bmp = FreeImage_LoadFromMemory(fif, hmem, 0);
if( bmp != NULL ){
bLoaded = true;
ofLog(OF_LOG_VERBOSE,"FreeImage_LoadFromMemory worked!\n");
}
//-----------------------------
if (bLoaded){
putBmpIntoPixels(bmp,pix);
} else {
width = height = bpp = 0;
}
if (bmp != NULL){
FreeImage_Unload(bmp);
}
if( hmem != NULL ){
FreeImage_CloseMemory(hmem);
}
return bLoaded;
}
static bool loadImage(ofPixels_<PixelType> & pix, const ofBuffer & buffer, const ofImageLoadSettings &settings){
ofInitFreeImage();
bool bLoaded = false;
FIBITMAP* bmp = nullptr;
FIMEMORY* hmem = nullptr;
hmem = FreeImage_OpenMemory((unsigned char*) buffer.getData(), buffer.size());
if (hmem == nullptr){
ofLogError("ofImage") << "loadImage(): couldn't load image from ofBuffer, opening FreeImage memory failed";
return false;
}
//get the file type!
FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(hmem);
if( fif == -1 ){
ofLogError("ofImage") << "loadImage(): couldn't load image from ofBuffer, unable to guess image format from memory";
FreeImage_CloseMemory(hmem);
return false;
}
//make the image!!
if(fif == FIF_JPEG) {
int option = getJpegOptionFromImageLoadSetting(settings);
bmp = FreeImage_LoadFromMemory(fif, hmem, option);
} else {
bmp = FreeImage_LoadFromMemory(fif, hmem, 0);
}
if( bmp != nullptr ){
bLoaded = true;
}
//-----------------------------
if (bLoaded){
putBmpIntoPixels(bmp,pix);
}
if (bmp != nullptr){
FreeImage_Unload(bmp);
}
if( hmem != nullptr ){
FreeImage_CloseMemory(hmem);
}
return bLoaded;
}
void CopyStream(EdsStreamRef stream, ofBuffer& buffer) {
EdsUInt32 length;
Eds::GetLength(stream, &length);
char* streamPointer;
Eds::GetPointer(stream, (EdsVoid**) &streamPointer);
buffer.set(streamPointer, length);
}
void ofxTurboJpeg::save(ofBuffer &buf, const ofPixels& pix, int jpegQuality)
{
int pitch = 0, flags = 0, jpegsubsamp = 0;
unsigned long size = 0;
if (pix.getImageType() == OF_IMAGE_COLOR)
{
int bpp = 3;
vector<unsigned char> buffer;
buffer.resize(pix.getWidth() * pix.getHeight() * bpp);
unsigned char * output = &buffer[0];
tjCompress(handleCompress, (unsigned char*)(pix.getData()), pix.getWidth(), pitch, pix.getHeight(), bpp, output, &size, jpegsubsamp, jpegQuality, flags);
buf.set((const char*)output, size);
}
else if (pix.getImageType() == OF_IMAGE_COLOR_ALPHA)
{
ofPixels p;
p.allocate(pix.getWidth(), pix.getHeight(), 3);
const unsigned char *src = pix.getData();
unsigned char *dst = p.getData();
int num = pix.getWidth() * pix.getHeight();
for (int i = 0; i < num; i++)
{
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
src += 4;
dst += 3;
}
save(buf, p, jpegQuality);
}
else if (pix.getImageType() == OF_IMAGE_GRAYSCALE)
{
ofPixels p;
p.allocate(pix.getWidth(), pix.getHeight(), 3);
const unsigned char *src = pix.getData();
unsigned char *dst = p.getData();
int num = pix.getWidth() * pix.getHeight();
for (int i = 0; i < num; i++)
{
dst[0] = src[0];
dst[1] = src[0];
dst[2] = src[0];
src += 1;
dst += 3;
}
save(buf, p, jpegQuality);
}
}
bool ofxTurboJpeg::load(const ofBuffer& buf, ofPixels &pix)
{
int w, h;
int subsamp;
int ok = tjDecompressHeader2(handleDecompress, (unsigned char*)buf.getData(), buf.size(), &w, &h, &subsamp);
if (ok != 0)
{
printf("Error in tjDecompressHeader2():\n%s\n", tjGetErrorStr());
return false;
}
pix.allocate(w, h, 3);
tjDecompress(handleDecompress, (unsigned char*)buf.getData(), buf.size(), pix.getData(), w, 0, h, 3, 0);
return true;
}
static bool loadImage(ofPixels_<PixelType> & pix, const ofBuffer & buffer){
ofInitFreeImage();
bool bLoaded = false;
FIBITMAP* bmp = NULL;
FIMEMORY* hmem = NULL;
hmem = FreeImage_OpenMemory((unsigned char*) buffer.getBinaryBuffer(), buffer.size());
if (hmem == NULL){
ofLogError("ofImage") << "loadImage(): couldn't load image from ofBuffer, opening FreeImage memory failed";
return false;
}
//get the file type!
FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(hmem);
if( fif == -1 ){
ofLogError("ofImage") << "loadImage(): couldn't load image from ofBuffer, unable to guess image format from memory";
return false;
FreeImage_CloseMemory(hmem);
}
//make the image!!
bmp = FreeImage_LoadFromMemory(fif, hmem, 0);
if( bmp != NULL ){
bLoaded = true;
}
//-----------------------------
if (bLoaded){
putBmpIntoPixels(bmp,pix);
}
if (bmp != NULL){
FreeImage_Unload(bmp);
}
if( hmem != NULL ){
FreeImage_CloseMemory(hmem);
}
return bLoaded;
}
static bool loadImage(ofPixels_<PixelType> & pix, const ofBuffer & buffer){
ofInitFreeImage();
bool bLoaded = false;
FIBITMAP* bmp = NULL;
FIMEMORY* hmem = NULL;
hmem = FreeImage_OpenMemory((unsigned char*) buffer.getBinaryBuffer(), buffer.size());
if (hmem == NULL){
ofLog(OF_LOG_ERROR, "couldn't create memory handle!");
return false;
}
//get the file type!
FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(hmem);
if( fif == -1 ){
ofLog(OF_LOG_ERROR, "unable to guess format", fif);
return false;
FreeImage_CloseMemory(hmem);
}
//make the image!!
bmp = FreeImage_LoadFromMemory(fif, hmem, 0);
if( bmp != NULL ){
bLoaded = true;
}
//-----------------------------
if (bLoaded){
putBmpIntoPixels(bmp,pix);
}
if (bmp != NULL){
FreeImage_Unload(bmp);
}
if( hmem != NULL ){
FreeImage_CloseMemory(hmem);
}
return bLoaded;
}
void PointHelper::get(ofBuffer &buffer) const
{
PointData data;
data.point = target_->point();
data.coord = target_->coord();
data.normal = target_->normal();
data.color = target_->color();
data.is_node = target_->isNode();
buffer.append((const char*)(&data), sizeof(PointData));
}
//-------------------------------------------
bool ofxAssimpModelLoader::loadModel(ofBuffer & buffer, bool optimize, const char * extension){
normalizeFactor = ofGetWidth() / 2.0;
if(scene != NULL){
clear();
}
// only ever give us triangles.
aiSetImportPropertyInteger(AI_CONFIG_PP_SBP_REMOVE, aiPrimitiveType_LINE | aiPrimitiveType_POINT );
aiSetImportPropertyInteger(AI_CONFIG_PP_PTV_NORMALIZE, true);
// aiProcess_FlipUVs is for VAR code. Not needed otherwise. Not sure why.
unsigned int flags = aiProcessPreset_TargetRealtime_MaxQuality | aiProcess_Triangulate | aiProcess_FlipUVs;
if(optimize) flags |= aiProcess_ImproveCacheLocality | aiProcess_OptimizeGraph |
aiProcess_OptimizeMeshes | aiProcess_JoinIdenticalVertices |
aiProcess_RemoveRedundantMaterials;
scene = aiImportFileFromMemory(buffer.getBinaryBuffer(), buffer.size(), flags, extension);
if(scene){
calculateDimensions();
loadGLResources();
update();
if(getAnimationCount())
ofLogVerbose("ofxAssimpModelLoader") << "loadModel(): scene has " << getAnimationCount() << "animations";
else {
ofLogVerbose("ofxAssimpModelLoader") << "loadMode(): no animations";
}
ofAddListener(ofEvents().exit,this,&ofxAssimpModelLoader::onAppExit);
return true;
}else{
ofLogError("ofxAssimpModelLoader") << "loadModel(): " + (string) aiGetErrorString();
clear();
return false;
}
}
void MeshHelper::get(ofBuffer &buffer) const
{
MeshData data;
data.divx = target_->getDivX();
data.divy = target_->getDivY();
data.resolution = target_->getChildMeshResolution();
data.uv_size = target_->getTexCoordSize();
buffer.append((const char*)(&data), sizeof(MeshData));
const vector<MeshPoint*> &points = target_->getPoints();
for(auto &p : points) {
PointHelper(p).get(buffer);
}
}
bool ofxZmqSocket::receive(ofBuffer &data)
{
int32_t more = 0;
size_t more_size = sizeof(more);
data.clear();
stringstream ss;
zmq::message_t m;
socket.recv(&m);
socket.getsockopt(ZMQ_RCVMORE, &more, &more_size);
const int numBytes = m.size();
const char *src = (const char*)m.data();
ss.write(src, numBytes);
data.set(ss);
return more;
}
//--------------------------------------------------
bool ofReadFile(const string & path, ofBuffer & buffer, bool binary){
ifstream * file = new ifstream(ofToDataPath(path,true).c_str());
if(!file || !file->is_open()){
ofLog(OF_LOG_ERROR, "couldn't open " + path);
return false;
}
filebuf *pbuf=file->rdbuf();
// get file size using buffer's members
long size = (long)pbuf->pubseekoff (0,ios::end,ios::in);
pbuf->pubseekpos (0,ios::in);
// get file data
if(!binary){
buffer.allocate(size+1);// = new char[size];
buffer.getBuffer()[size]='\0';
}else{
buffer.allocate(size);
}
pbuf->sgetn (buffer.getBuffer(),size);
return true;
}
bool ofxAssimpModelLoader::loadModel(ofBuffer & buffer, bool optimize, const char * extension){
ofLogVerbose("ofxAssimpModelLoader") << "loadModel(): loading from memory buffer \"." << extension << "\"";
if(scene != NULL){
clear();
}
// sets various properties & flags to a default preference
unsigned int flags = initImportProperties(optimize);
// loads scene from memory buffer - note this will not work for multipart files (obj, md3, etc)
scene = shared_ptr<const aiScene>(aiImportFileFromMemoryWithProperties(buffer.getBinaryBuffer(), buffer.size(), flags, extension, store.get()), aiReleaseImport);
bool bOk = processScene();
return bOk;
}
bool ofxAssimpModelLoader::loadModel(ofBuffer & buffer, bool optimize, const char * extension){
ofLogVerbose("ofxAssimpModelLoader") << "loadModel(): loading from memory buffer \"." << extension << "\"";
if(scene.get() != nullptr){
clear();
// we reset the shared_ptr explicitly here, to force the old
// aiScene to be deleted **before** a new aiScene is created.
scene.reset();
}
// sets various properties & flags to a default preference
unsigned int flags = initImportProperties(optimize);
// loads scene from memory buffer - note this will not work for multipart files (obj, md3, etc)
scene = shared_ptr<const aiScene>(aiImportFileFromMemoryWithProperties(buffer.getData(), buffer.size(), flags, extension, store.get()), aiReleaseImport);
bool bOk = processScene();
return bOk;
}
static bool saveImage(const ofPixels_<PixelType> & _pix, ofBuffer & buffer, ofImageFormat format, ofImageQualityType qualityLevel) {
// thanks to alvaro casinelli for the implementation
ofInitFreeImage();
if (_pix.isAllocated() == false){
ofLogError("ofImage","saveImage(): couldn't save to ofBuffer, pixels are not allocated");
return false;
}
if(format==OF_IMAGE_FORMAT_JPEG && (_pix.getNumChannels()==4 || _pix.getBitsPerChannel() > 8)){
ofPixels pix3 = _pix;
pix3.setNumChannels(3);
return saveImage(pix3,buffer,format,qualityLevel);
}
FIBITMAP * bmp = nullptr;
#ifdef TARGET_LITTLE_ENDIAN
if(sizeof(PixelType) == 1 && (_pix.getPixelFormat()==OF_PIXELS_RGB || _pix.getPixelFormat()==OF_PIXELS_RGBA)) { // Make a local copy.
ofPixels_<PixelType> pix = _pix;
pix.swapRgb();
bmp = getBmpFromPixels(pix);
}else{
#endif
bmp = getBmpFromPixels(_pix);
#ifdef TARGET_LITTLE_ENDIAN
}
#endif
if (bmp) // bitmap successfully created
{
bool returnValue;
// (b) open a memory stream to compress the image onto mem_buffer:
//
FIMEMORY *hmem = FreeImage_OpenMemory();
// (c) encode and save the image to the memory (on dib FIBITMAP image):
//
if(FREE_IMAGE_FORMAT(format) == FIF_JPEG) {
int quality = JPEG_QUALITYSUPERB;
switch(qualityLevel) {
case OF_IMAGE_QUALITY_WORST: quality = JPEG_QUALITYBAD; break;
case OF_IMAGE_QUALITY_LOW: quality = JPEG_QUALITYAVERAGE; break;
case OF_IMAGE_QUALITY_MEDIUM: quality = JPEG_QUALITYNORMAL; break;
case OF_IMAGE_QUALITY_HIGH: quality = JPEG_QUALITYGOOD; break;
case OF_IMAGE_QUALITY_BEST: quality = JPEG_QUALITYSUPERB; break;
}
returnValue = FreeImage_SaveToMemory(FIF_JPEG, bmp, hmem, quality);
}else{
returnValue = FreeImage_SaveToMemory((FREE_IMAGE_FORMAT)format, bmp, hmem);
}
/*
NOTE: at this point, hmem contains the entire data in memory stored in fif format. the
amount of space used by the memory is equal to file_size:
long file_size = FreeImage_TellMemory(hmem);
but can also be retrieved by FreeImage_AcquireMemory that retrieves both the
length of the buffer, and the buffer memory address.
*/
#ifdef TARGET_WIN32
DWORD size_in_bytes = 0;
#else
std::uint32_t size_in_bytes = 0;
#endif
// Save compressed data on mem_buffer
// note: FreeImage_AquireMemory allocates space for aux_mem_buffer):
//
unsigned char *mem_buffer = nullptr;
if (!FreeImage_AcquireMemory(hmem, &mem_buffer, &size_in_bytes)){
ofLogError("ofImage") << "saveImage(): couldn't save to ofBuffer, aquiring compressed image from memory failed";
return false;
}
/*
Now, before closing the memory stream, copy the content of mem_buffer
to an auxiliary buffer
*/
buffer.set((char*)mem_buffer,size_in_bytes);
// Finally, close the FIBITMAP object, or we will get a memory leak:
FreeImage_Unload(bmp);
// Close the memory stream (otherwise we may get a memory leak).
FreeImage_CloseMemory(hmem);
return returnValue;
}else{
return false;
}
}
static void saveImage(ofPixels_<PixelType> & pix, ofBuffer & buffer, ofImageFormat format, ofImageQualityType qualityLevel) {
//thanks to alvaro casinelli for the implementation
ofInitFreeImage();
if (pix.isAllocated() == false){
ofLog(OF_LOG_ERROR,"error saving image - pixels aren't allocated");
return;
}
#ifdef TARGET_LITTLE_ENDIAN
if(sizeof(PixelType) == 1) {
pix.swapRgb();
}
#endif
FIBITMAP * bmp = getBmpFromPixels(pix);
#ifdef TARGET_LITTLE_ENDIAN
if(sizeof(PixelType) == 1) {
pix.swapRgb();
}
#endif
if (bmp) // bitmap successfully created
{
// (b) open a memory stream to compress the image onto mem_buffer:
//
FIMEMORY *hmem = FreeImage_OpenMemory();
// (c) encode and save the image to the memory (on dib FIBITMAP image):
//
if(FREE_IMAGE_FORMAT(format) == FIF_JPEG) {
int quality = JPEG_QUALITYSUPERB;
switch(qualityLevel) {
case OF_IMAGE_QUALITY_WORST: quality = JPEG_QUALITYBAD; break;
case OF_IMAGE_QUALITY_LOW: quality = JPEG_QUALITYAVERAGE; break;
case OF_IMAGE_QUALITY_MEDIUM: quality = JPEG_QUALITYNORMAL; break;
case OF_IMAGE_QUALITY_HIGH: quality = JPEG_QUALITYGOOD; break;
case OF_IMAGE_QUALITY_BEST: quality = JPEG_QUALITYSUPERB; break;
}
FreeImage_SaveToMemory(FIF_JPEG, bmp, hmem, quality);
}else{
FreeImage_SaveToMemory((FREE_IMAGE_FORMAT)format, bmp, hmem);
}
/*
NOTE: at this point, hmem contains the entire data in memory stored in fif format. the
amount of space used by the memory is equal to file_size:
long file_size = FreeImage_TellMemory(hmem);
but can also be retrieved by FreeImage_AcquireMemory that retrieves both the
length of the buffer, and the buffer memory address.
*/
#ifdef TARGET_WIN32
DWORD size_in_bytes = 0;
#else
uint32_t size_in_bytes = 0;
#endif
// Save compressed data on mem_buffer
// note: FreeImage_AquireMemory allocates space for aux_mem_buffer):
//
unsigned char *mem_buffer = NULL;
if (!FreeImage_AcquireMemory(hmem, &mem_buffer, &size_in_bytes))
cout << "Error aquiring compressed image from memory" << endl;
/*
Now, before closing the memory stream, copy the content of mem_buffer
to an auxiliary buffer
*/
buffer.set((char*)mem_buffer,size_in_bytes);
// Finally, close the FIBITMAP object, or we will get a memory leak:
FreeImage_Unload(bmp);
// Close the memory stream (otherwise we may get a memory leak).
FreeImage_CloseMemory(hmem);
}
}
//----------------------------------------------------------------
long ofSerial::writeBytes(const ofBuffer & buffer){
return writeBytes(buffer.getData(),buffer.size());
}
//----------------------------------------------------------------
long ofSerial::readBytes(ofBuffer & buffer, size_t length){
buffer.allocate(length);
return readBytes(buffer.getData(),length);
}
int ofxNanomsgPublisher::send(const string &topic, const ofBuffer &data, bool nonblocking)
{
return ofxNanomsgSocket::send(topic + " " + data.getBinaryBuffer(), nonblocking);
}
//--------------------------------------------------------------
void Server::sendBinary( ofBuffer buffer ){
sendBinary(buffer.getBinaryBuffer(), buffer.size());
}
// ----------------------------------------------------------------------
ofxHttpResponse ofxHttpUtils::postData(string url, const ofBuffer & data, string contentType){
ofxHttpResponse response;
try{
URI uri( url.c_str() );
std::string path(uri.getPathAndQuery());
if (path.empty()) path = "/";
//HTTPClientSession session(uri.getHost(), uri.getPort());
HTTPRequest req(HTTPRequest::HTTP_POST, path, HTTPMessage::HTTP_1_1);
if(auth.getUsername()!="") auth.authenticate(req);
if(sendCookies){
for(unsigned i=0; i<cookies.size(); i++){
NameValueCollection reqCookies;
reqCookies.add(cookies[i].getName(),cookies[i].getValue());
req.setCookies(reqCookies);
}
}
if(contentType!=""){
req.setContentType(contentType);
}
req.setContentLength(data.size());
HTTPResponse res;
ofPtr<HTTPSession> session;
istream * rs;
if(uri.getScheme()=="https"){
HTTPSClientSession * httpsSession = new HTTPSClientSession(uri.getHost(), uri.getPort());//,context);
httpsSession->setTimeout(Poco::Timespan(20,0));
httpsSession->sendRequest(req) << data;
rs = &httpsSession->receiveResponse(res);
session = ofPtr<HTTPSession>(httpsSession);
}else{
HTTPClientSession * httpSession = new HTTPClientSession(uri.getHost(), uri.getPort());
httpSession->setTimeout(Poco::Timespan(20,0));
httpSession->sendRequest(req) << data;
rs = &httpSession->receiveResponse(res);
session = ofPtr<HTTPSession>(httpSession);
}
response = ofxHttpResponse(res, *rs, url);
if(sendCookies){
cookies.insert(cookies.begin(),response.cookies.begin(),response.cookies.end());
}
if(response.status>=300 && response.status<400){
Poco::URI uri(req.getURI());
uri.resolve(res.get("Location"));
response.location = uri.toString();
}
ofNotifyEvent(newResponseEvent, response, this);
}catch (Exception& exc){
ofLogError("ofxHttpUtils") << "ofxHttpUtils error postData --";
//ofNotifyEvent(notifyNewError, "time out", this);
// for now print error, need to broadcast a response
ofLogError("ofxHttpUtils") << exc.displayText();
response.status = -1;
response.reasonForStatus = exc.displayText();
ofNotifyEvent(newResponseEvent, response, this);
}
return response;
}
vector<Mesh*> Loader::load(const ofBuffer &buffer)
{
return load(buffer.getData(), buffer.size());
}
bool ofxZmqSocket::send(const ofBuffer &data, bool nonblocking, bool more)
{
return ofxZmqSocket::send((const void*)data.getBinaryBuffer(), data.size(), nonblocking, more);
}
void ramTSVCoder::decode(ofBuffer buffer)
{
if (buffer.size())
{
clear();
do
{
string frame = buffer.getNextLine();
vector<string> values = ofSplitString(frame, "\t");
if (values.size() < 2)
throw std::exception();
const string addr = values.at(0);
const string name = values.at(1);
ramNodeArray NA;
if (addr == RAM_OSC_ADDR_ACTOR)
{
ramActor o;
o.setType(RAM_NODEARRAY_TYPE_ACTOR);
o.setName(name);
NA = o;
}
else
{
ramRigidBody o;
o.setType(RAM_NODEARRAY_TYPE_RIGIDBODY);
o.setName(name);
NA = o;
}
const int numNodes = ofToInt(values.at(2));
for (int i=0; i<numNodes; i++)
{
if (values.size() < i*8+3+7)
throw std::exception();
const string nodeName = values.at(i*8 + 0 + 3);
const float vx = ofToFloat( values.at(i*8 + 1 + 3) );
const float vy = ofToFloat( values.at(i*8 + 2 + 3) );
const float vz = ofToFloat( values.at(i*8 + 3 + 3) );
const float qa = ofToFloat( values.at(i*8 + 4 + 3) );
const float ax = ofToFloat( values.at(i*8 + 5 + 3) );
const float ay = ofToFloat( values.at(i*8 + 6 + 3) );
const float az = ofToFloat( values.at(i*8 + 7 + 3) );
const ofVec3f vec(vx, vy, vz);
const ofVec3f axis(ax, ay, az);
const ofQuaternion quat(qa, axis);
ramNode &node = NA.getNode(i);
node.setID(i);
node.setName(nodeName);
node.setPosition(vec);
node.setOrientation(quat);
node.getAccelerometer().update(vec, quat);
}
NA.setTimestamp(ofToFloat( values.at(numNodes*8 + 0 + 3) ));
mSession.appendFrame(NA);
} while (!buffer.isLastLine());
// cout << "[" << __FUNCTION__ << "] " << "File loaded! " << endl;
// cout << "[" << __FUNCTION__ << "] " << "Actor: " << mSession.getNodeArrayName() << endl;
// cout << "[" << __FUNCTION__ << "] " << "Duration: " << mSession.getDuration() << "sec"<< endl;
// cout << "[" << __FUNCTION__ << "] " << "Frames: " << mSession.getNumFrames() << endl << endl;
}
// return mSession;
}
