void watch(string vertName, string fragName)
{
vertShader.open(vertName);
fragShader.open(fragName);
ofAddListener(ofEvents().update, this, &AutoLoadShader::onUpdate);
}
void onUpdate(ofEventArgs &e)
{
if (lastVertTimestamp != vertShader.getPocoFile().getLastModified()
|| lastFragTimestamp != fragShader.getPocoFile().getLastModified())
{
reload();
}
}
// ---------------------------------------------------------------------------------------------------------------------------------------------------
//
std::time_t ofxAutoReloadedShader::getLastModified( ofFile& _file )
{
if( _file.exists() )
{
return std::filesystem::last_write_time(_file.path());
}
else
{
return 0;
}
}
std::time_t UIShader::getLastModified( ofFile& _file ){
if( _file.exists() ){
Poco::File& pocoFile = _file.getPocoFile();
Poco::Timestamp timestamp = pocoFile.getLastModified();
std::time_t fileChangedTime = timestamp.epochTime();
return fileChangedTime;
} else {
return 0;
}
}
//--------------------------------------------------------------
void ofApp::processFile(ofFile & file) {
cout << file.getAbsolutePath() << endl;
auto extension = ofToLower(file.getExtension());
cout << extension << endl;
if (extension == "jpg" || extension == "jpeg" || extension == "png") {
ofImage loader;
ofLogNotice("ofApp::dragEvent") << "loading " << file.getFileName() << " #" << decoder.getFrame();
loader.loadImage(file);
ofLogNotice("ofApp::dragEvent") << "adding " << file.getFileName();
decoder << loader;
} else if (extension == "sl") {
this->decoder.loadDataSet(file.getAbsolutePath());
}
}
long getUpdateTime(ofFile &file) {
struct stat fileStat;
if(stat(file.path().c_str(), &fileStat) < 0) {
printf("Couldn't stat file\n");
return;
}
return fileStat.st_mtime;
}
//--------------------------------------------------------------
void ArtvertiserApp::artvertSelected(ofFile & artvertimg){
subs_img.setup( artvertimg.getAbsolutePath() );
state = Tracking;
artvertInfo.stop();
Artvert & artvert = artvertInfo.getCurrentArtvert();
if(artvert.hasAlias()){
artvertiser.setup(artvert.getAlias().getModel().getAbsolutePath(),grabber,subs_img.getImgQuad(), false, detectW, detectH );
ofLogVerbose("ArtvertiserApp", "artvert.hasAlias()");
}else{
ofLogVerbose("ArtvertiserApp", "doesn't: artvert.hasAlias()");
artvertiser.setup(artvert.getModel().getAbsolutePath(),grabber,subs_img.getImgQuad(), false, detectW, detectH );
}
}
void testApp::writeLog(){
//-------------------------
// Writing machine learning data
if(bTracking && bCalibrated){
state = 0; // state is used for machine learning mark-up
if(keys['1']) state = 1;
if(keys['2']) state = 2;
// if(keys['3']) state = 3;
logFile << trackers[0].lerpedPos.x << " " << trackers[0].lerpedPos.z << " "
<< trackers[1].lerpedPos.x << " " << trackers[1].lerpedPos.z << " "
<< trackers[2].lerpedPos.x << " " << trackers[2].lerpedPos.z << " " << state << endl;
cout << trackers[0].lerpedPos.x << " " << trackers[0].lerpedPos.z << " "
<< trackers[1].lerpedPos.x << " " << trackers[1].lerpedPos.z << " "
<< trackers[2].lerpedPos.x << " " << trackers[2].lerpedPos.z << " " << state << endl;
logFile.flush();
}
}
void reload()
{
load(vertShader.path(), fragShader.path());
}
void ofImage_<PixelType>::saveImage(const ofFile & file, ofImageQualityType compressionLevel){
ofSaveImage(pixels,file.getAbsolutePath(),compressionLevel);
}
bool ofImage_<PixelType>::loadImage(const ofFile & file){
return loadImage(file.getAbsolutePath());
}
bool ofImage_<PixelType>::load(const ofFile & file, const ofImageLoadSettings &settings){
return load(file.getAbsolutePath(), settings);
}
//--------------------------------------------------------------
void testApp::setup(){
ofBackground(0);
ofSetFrameRate(60);
int PORT = 12000;
int REMOTE_PORT = 12000;
string REMOTE_HOST = "169.254.0.1";
receiver.setup(PORT);
sender.setup(REMOTE_HOST, REMOTE_PORT);
sprintf(oscStatus, "[LOCALPORT] %d\n[REMOTE PORT] (%s, %5d)\n", PORT, REMOTE_HOST.c_str(), REMOTE_PORT);
gui.setup();
gui.addTitle("TRACKER \n[i] hide controls");
gui.addToggle("TRACK", bTracking).setSize(200, 20);
calibratedButton = &gui.addToggle("CALIBRATED", bCalibrated);
calibratedButton->setSize(200, 20);
gui.addToggle("SAVE", bSaving).setSize(200, 20);
gui.addButton("Load MeshLab File", bLoadMLP).setSize(200, 20);
gui.addButton("Reset Server Counter", bReset).setSize(200, 20);
gui.addSlider("Zoom", camZoom, -5000, 5000).setSmoothing(0.9);
gui.addSlider("camPosX", camPosX, -200, 200).setSmoothing(0.9);
gui.addSlider("camPosY", camPosY, -200, 200).setSmoothing(0.9);
gui.addSlider("camRotX", camRotX, 0, 360).setSmoothing(0.9);
gui.addSlider("camRotY", camRotY, 0, 360).setSmoothing(0.9);
gui.addToggle("Lock top view", bTop).setSize(200, 20);
gui.addToggle("Enable ghost 1", bGhost0).setSize(200, 20);
gui.addToggle("Enable ghost 2", bGhost1).setSize(200, 20);
gui.addButton("Set Center", bSetCenter).setSize(200, 20);
gui.addButton("Set Ref Point", bSetRefPoint).setSize(200, 20);
gui.addButton("Set Ghost 1", bSetGhost0).setSize(200, 20);
gui.addButton("Set Ghost 2", bSetGhost1).setSize(200, 20);
status = &gui.addTitle("STATUS");
status->setNewColumn(true);
gui.loadFromXML();
gui.show();
matrixData.setup();
// LOAD space references
XML.loadFile(ofToDataPath("xmlSettings.xml"));
int cX = XML.getValue("CENTER_X", 0);
int cZ = XML.getValue("CENTER_Z", 0);
int rX = XML.getValue("REF_X", 0);
int rZ = XML.getValue("REF_Z", 0);
center = ofVec3f(cX, 0, cZ);
refPoint = ofVec3f(rX, 0, rZ);
refVector = center - refPoint;
for(int i = 0; i < K; i++){
kinects[i].setMatrix(matrixData.getMatrix(i));
kinects[i].setCenter(center, refVector);
}
// LOAD GHOSTS
int gX, gZ;
gX = XML.getValue("GHOST_0_X", 0);
gZ = XML.getValue("GHOST_0_Z", 0);
ghost0 = ofVec3f(gX, 0, gZ);
gX = XML.getValue("GHOST_1_X", 0);
gZ = XML.getValue("GHOST_1_Z", 0);
ghost1 = ofVec3f(gX, 0, gZ);
//-----
bTracking = false;
bCalibrated = false;
bSaving = false;
pbSaving = false;
bReset = false;
bTop = false;
// Purge old osc messages
while(receiver.hasWaitingMessages()){
ofxOscMessage m;
receiver.getNextMessage(&m);
}
logFile.open("log.txt", ofFile::WriteOnly, false);
/*
AAAAAdasdasdadsa
bGhost0 = true;
bGhost1 = true;
*/
}
template <class T> void writeRaw(ofFile& out, T data) {
out.write((char*) &data, sizeof(data));
}
template <class T> void readRaw(ofFile& in, T& data) {
in.read((char*) &data, sizeof(data));
}
// Create the clusters out of the image
ImgTexture ImgTextureFactory::CreateImage(const ofFile& inImageFile, const ofFile& inClusterFile)
{
std::cout << "\nCreating Image: " << inImageFile.getFileName() << "\n";
std::cout << "\nCreating Clustered Image: " << inClusterFile.getFileName() << "\n";
// First create an image out of the incoming file, this can have any format
ofImage image;
image.loadImage(inImageFile);
assert(image.isAllocated());
// Load our clustered image in a pixel buffer
ofPixels clustered_pix;
ofLoadImage(clustered_pix, inClusterFile.getFileName());
/*
// Load our sample image in a pixel buffer
ofPixels clustered_sample_pix;
ofLoadImage(clustered_pix, inClusterFile.getFileName());
*/
// Now create our clustered image, this needs to be of a type (rgba, 8bc)
assert(clustered_pix.isAllocated());
assert(clustered_pix.getImageType() == OF_IMAGE_COLOR_ALPHA);
assert(clustered_pix.getBitsPerPixel() == 32);
// Will hold the final amount of clusters
int cluster_counter = 0;
// Used for storing the color value
std::vector<BYTE> colors;
std::vector<int> color_refs;
// Now get the pixels and iterate over them
// We sample how many clusters there are in the image,
// The colors that belong to that cluster and how many times that color appears in the image
BYTE* pixels = clustered_pix.getPixels();
for (int x=0; x < clustered_pix.getWidth(); x++)
{
for(int y=0; y < clustered_pix.getHeight(); y++)
{
// Get the current read pos and sample color
int read_pos = ((y*clustered_pix.getWidth())+ x) * 4;
// Make sure alpha is not 0
if(pixels[read_pos+3] < 2)
continue;
BYTE color = pixels[read_pos];
// See if it's in the colors array, if not add
bool already_present = false;
int color_counter = 0;
for(std::vector<BYTE>::iterator it = colors.begin(); it != colors.end(); ++it)
{
// Get the color and sample within a range
BYTE p_color = *it;
if(!(color > *it+2) && !(color < *it-2))
{
already_present = true;
(color_refs[color_counter])++;
break;
}
// Increment color counter
color_counter++;
}
if(!already_present)
{
colors.push_back(color);
color_refs.push_back(1);
cluster_counter++;
}
}
}
// Now delete the clusters that don't have enough pixels
std::vector<BYTE> final_color_set;
int counter = 0;
int fclusters = 0;
for(std::vector<int>::iterator it = color_refs.begin(); it != color_refs.end(); ++it)
{
if(*it >= MIN_CLUSTER_PIXEL_COUNT)
{
final_color_set.push_back(colors[counter]);
fclusters++;
}
counter++;
}
// Sort the remaining ones based on color
vector<BYTE>::iterator it;
sort(final_color_set.begin(), final_color_set.end());
// Return a new texture that holds the image and clusters
return ImgTexture(image, clustered_pix, fclusters, final_color_set);
}
