XMLParser::XMLParser(string path)
{
// Debug-Objekt erstellen, so dass Dateiname und eventuelle Fehlermeldung gleiche Nummer haben
Debug dbg = Debug() ;
dbg.message("Parse XML-File: " + path) ;
filepath = path ;
file.open(filepath.c_str(), ios_base::in) ;
// überprüfen, ob die Datei existiert
if (!file) {
dbg.message("Datei '" + path + "' nicht gefunden") ;
} else {
string filecontent ;
char character ;
while(!file.eof()) {
file.get(character) ;
filecontent += character ;
}
// Mainnodes herausfinden und gesamte Datei in Nodes aufsplitten
splitMainNodes(filecontent) ;
}
file.close() ;
}
int main(int argc, char *argv[])
{
Debug dbg ;
if (2 == argc)
{
dbg.SetExePathName(argv[1]) ;
}
else
{
char szFileName[256] = "" ;
OPENFILENAME file = {0} ;
file.lpstrFile = szFileName ;
file.lStructSize = sizeof(OPENFILENAME) ;
file.nMaxFile = 256 ;
file.lpstrFilter = "Executables\0*.exe\0All Files\0*.*\0\0" ;
file.nFilterIndex = 1 ;
if(::GetOpenFileName(&file))
{
dbg.SetExePathName(szFileName) ;
}
}
dbg.StartDebug() ;
system("pause") ;
return 0 ;
}
int main() {
constexpr Debug io_sub(false, true, false);
if (io_sub.any())
std::cerr << "print appropriate error messages" << std::endl;
constexpr Debug prod(false);
if (prod.any())
std::cerr << "print an error message" << std::endl;
}
int main()
{
constexpr Debug io_sub(false, true ,false);
if(io_sub.any()){
cerr << "printf appropriate error messages" << endl;
}
constexpr Debug prod(false);
if(prod.any()){
cerr << "printf an error message" << endl;
}
return 0;
}
static int test_sales_data()
{
// Sales_data data(cin);
// print(cout, data);
X2 x2(5);
x2.print();
X2 x2_default;
x2_default.print();
constexpr Debug d;
constexpr int c_i = d.any();
return 0;
}
int dvbsub_init()
{
printf("dvbsub_init: starting... tid %ld\n", syscall(__NR_gettid));
int trc;
sub_debug.set_level(1);
reader_running = true;
dvbsub_stopped = 1;
pid_change_req = 1;
// reader-Thread starten
trc = pthread_create(&threadReader, 0, reader_thread, (void *) NULL);
if (trc) {
fprintf(stderr, "[dvb-sub] failed to create reader-thread (rc=%d)\n", trc);
reader_running = false;
return -1;
}
dvbsub_running = true;
// subtitle decoder-Thread starten
trc = pthread_create(&threadDvbsub, 0, dvbsub_thread, NULL);
if (trc)
{
fprintf(stderr, "[dvb-sub] failed to create dvbsub-thread (rc=%d)\n", trc);
dvbsub_running = false;
return -1;
}
return(0);
}
bool CGame::Initialize()
{
Debug *dbg = Debug::GetInstance();
if(SDL_Init(SDL_INIT_EVERYTHING) == -1)
{
dbg->Print("SDL_Init Failed /n");
return false;
}
if(m_FullScreen == true)
{
mainScreen = SDL_SetVideoMode(SCREEN_W,SCREEN_H,SCREEN_BPP,SDL_SWSURFACE|SDL_FULLSCREEN|SDL_DOUBLEBUF);
}
else if(m_FullScreen == false)
{
mainScreen = SDL_SetVideoMode(SCREEN_W,SCREEN_H,SCREEN_BPP,SDL_SWSURFACE);
}
if(mainScreen == NULL)
{
dbg->Print("Could not Initialize Screen!");
return false;
}
if(TTF_Init() == -1)
{
dbg->Print("TTF_Init Failed");
return false;
}
if(Mix_OpenAudio(MIX_DEFAULT_FREQUENCY,MIX_DEFAULT_FORMAT,MIX_DEFAULT_CHANNELS,4096) == -1)
{
dbg->Print("SDL_Mixer failed/n");
return false;
}
SDL_WM_SetCaption("Alana's Valentine's Day Gift", NULL);
return true;
}
void DebugTest::flags() {
std::ostringstream out;
Debug::setOutput(&out);
{
/* Don't allow to set/reset the reserved flag */
Debug debug;
debug.setFlag(static_cast<Debug::Flag>(0x01), false);
CORRADE_VERIFY(debug.flag(static_cast<Debug::Flag>(0x01)));
} {
Debug debug;
debug.setFlag(Debug::SpaceAfterEachValue, false);
debug << "a" << "b" << "c";
}
CORRADE_COMPARE(out.str(), "abc\n");
out.str("");
{
Debug debug;
debug.setFlag(Debug::NewLineAtTheEnd, false);
debug << "a" << "b" << "c";
}
CORRADE_COMPARE(out.str(), "a b c");
}
int main()
{
Scales_data item;
std::string null_book = "9-999-99999-9";
item.combine(null_book);
print(std::cout, item) << std::endl;
constexpr Debug io_sub(false, true, false);
if (io_sub.any())
std::cerr << "print appropriate error messages" << std::endl;
constexpr Debug prob(false);
if (prob.any())
std::cerr << "print an error messages" << std::endl;
// Scales_data total(std::cin);
std::string null_book("abc");
// Scales_data item = null_book; // explicit Scales_data(std::string) cause error
Scales_data item;
item.combine(Scales_data(null_book));
item.combine(static_cast<Scales_data>(std::cin));
Screen myScreen(5, 3, '$');
const Screen blank(5, 3, '0');
myScreen.move(1, 3).set('#').display(std::cout);
blank.display(std::cout);
std::cout << std::endl;
Window_mgr my_windows({myScreen, blank});
my_windows.display();
my_windows.clear(0);
my_windows.display();
Screen::pos ht(24), wd(80);
Screen scr(ht, wd, ' ');
Screen *p = &scr;
char c = scr.get();
c = p->get();
std::cout << c << std::endl;
}
void Nuria::Debug::qtMessageHandler (QtMsgType type, const QMessageLogContext &context,
const QString &message) {
Type t = DebugMsg;
// Translate QtMsgType to a Debug::Type value
switch (type) {
case QtDebugMsg:
t = DebugMsg;
break;
case QtWarningMsg:
t = WarnMsg;
break;
case QtCriticalMsg:
case QtFatalMsg:
t = CriticalMsg;
break;
}
// Output.
Debug out (t, context.category, context.file, context.line, context.function, 0);
out.setBuffer (message);
}
int dvbsub_init() {
int trc;
sub_debug.set_level(0);
reader_running = true;
dvbsub_stopped = 1;
pid_change_req = 1;
// reader-Thread starten
trc = pthread_create(&threadReader, 0, reader_thread, NULL);
if (trc) {
fprintf(stderr, "[dvb-sub] failed to create reader-thread (rc=%d)\n", trc);
reader_running = false;
return -1;
}
dvbsub_running = true;
// subtitle decoder-Thread starten
trc = pthread_create(&threadDvbsub, 0, dvbsub_thread, NULL);
if (trc) {
fprintf(stderr, "[dvb-sub] failed to create dvbsub-thread (rc=%d)\n", trc);
dvbsub_running = false;
return -1;
}
#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE
ass_reader_running = true;
sem_init(&ass_sem, 0, 0);
trc = pthread_create(&threadAss, 0, ass_reader_thread, NULL);
if (trc) {
fprintf(stderr, "[dvb-sub] failed to create %s-thread (rc=%d)\n", "ass-reader", trc);
ass_reader_running = false;
return -1;
}
pthread_detach(threadAss);
#endif
return(0);
}
// return true to retry later (e.g. after display lost)
static bool MainLoop(bool retryCreate)
{
TextureBuffer * eyeRenderTexture[2] = { nullptr, nullptr };
DepthBuffer * eyeDepthBuffer[2] = { nullptr, nullptr };
ovrGLTexture * mirrorTexture = nullptr;
GLuint mirrorFBO = 0;
ovrHmd HMD;
ovrGraphicsLuid luid;
ovrResult result = ovr_Create(&HMD, &luid);
if (!OVR_SUCCESS(result))
return retryCreate;
ovrHmdDesc hmdDesc = ovr_GetHmdDesc(HMD);
// Setup Window and Graphics
// Note: the mirror window can be any size, for this sample we use 1/2 the HMD resolution
ovrSizei windowSize = { hmdDesc.Resolution.w / 2, hmdDesc.Resolution.h / 2 };
if (!Platform.InitDevice(windowSize.w, windowSize.h, reinterpret_cast<LUID*>(&luid)))
goto Done;
debug.init(debug.VERBOSE);
opengl.init(1600, 700);
GameObject *box = new GameObject(vec3(0, 2, 0), vec3(0, 0, 0), vec3(1, 1, 1));
Model *box_model = new Model();
box_model->autoRotate = true;
//box_model->init_from_obj_file(L"box_red_4d.obj");
box_model->init_from_obj_file(L"hypercube.obj");
box->add_game_component((GameComponent *)box_model);
opengl.init_buffer(box_model->vertexBuffer, box_model->verts4D, GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW);
opengl.init_buffer(box_model->indiciesBuffer, box_model->indices, GL_ELEMENT_ARRAY_BUFFER, GL_STATIC_DRAW);
opengl.bind_vertex_indices(box_model);
scene.add_game_object(box);
GameObject *box1 = new GameObject(vec3(5, 5, 0), vec3(0, 0, 0), vec3(1, 1, 1));
Model *box_model1 = new Model();
box_model1->autoRotate = false;
box_model1->init_from_obj_file(L"hypercube.obj");
//box_model->init_from_obj_file(L"hypercube.obj");
box1->add_game_component((GameComponent *)box_model1);
opengl.init_buffer(box_model1->vertexBuffer, box_model1->verts4D, GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW);
opengl.init_buffer(box_model1->indiciesBuffer, box_model1->indices, GL_ELEMENT_ARRAY_BUFFER, GL_STATIC_DRAW);
opengl.bind_vertex_indices(box_model1);
scene.add_game_object(box1);
// Make eye render buffers
for (int eye = 0; eye < 2; ++eye)
{
ovrSizei idealTextureSize = ovr_GetFovTextureSize(HMD, ovrEyeType(eye), hmdDesc.DefaultEyeFov[eye], 1);
eyeRenderTexture[eye] = new TextureBuffer(HMD, true, true, idealTextureSize, 1, NULL, 1);
eyeDepthBuffer[eye] = new DepthBuffer(eyeRenderTexture[eye]->GetSize(), 0);
if (!eyeRenderTexture[eye]->TextureSet)
{
if (retryCreate) goto Done;
VALIDATE(false, "Failed to create texture.");
}
}
// Create mirror texture and an FBO used to copy mirror texture to back buffer
result = ovr_CreateMirrorTextureGL(HMD, GL_SRGB8_ALPHA8, windowSize.w, windowSize.h, reinterpret_cast<ovrTexture**>(&mirrorTexture));
if (!OVR_SUCCESS(result))
{
if (retryCreate) goto Done;
VALIDATE(false, "Failed to create mirror texture.");
}
// Configure the mirror read buffer
glGenFramebuffers(1, &mirrorFBO);
glBindFramebuffer(GL_READ_FRAMEBUFFER, mirrorFBO);
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, mirrorTexture->OGL.TexId, 0);
glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
ovrEyeRenderDesc EyeRenderDesc[2];
EyeRenderDesc[0] = ovr_GetRenderDesc(HMD, ovrEye_Left, hmdDesc.DefaultEyeFov[0]);
EyeRenderDesc[1] = ovr_GetRenderDesc(HMD, ovrEye_Right, hmdDesc.DefaultEyeFov[1]);
// Turn off vsync to let the compositor do its magic
wglSwapIntervalEXT(0);
bool isVisible = true;
// Main loop
while (Platform.HandleMessages())
{
// Keyboard inputs to adjust player orientation
static float Yaw(3.141592f);
if (Platform.Key[VK_LEFT]) Yaw += 0.02f;
if (Platform.Key[VK_RIGHT]) Yaw -= 0.02f;
// Keyboard inputs to adjust player position
static Vector3f Pos2(4.0f,0.0f,-10.0f);
if (Platform.Key['W']||Platform.Key[VK_UP]) Pos2+=Matrix4f::RotationY(Yaw).Transform(Vector3f(0,0,-0.05f));
if (Platform.Key['S']||Platform.Key[VK_DOWN]) Pos2+=Matrix4f::RotationY(Yaw).Transform(Vector3f(0,0,+0.05f));
if (Platform.Key['D']) Pos2+=Matrix4f::RotationY(Yaw).Transform(Vector3f(+0.05f,0,0));
if (Platform.Key['A']) Pos2+=Matrix4f::RotationY(Yaw).Transform(Vector3f(-0.05f,0,0));
Pos2.y = ovr_GetFloat(HMD, OVR_KEY_EYE_HEIGHT, Pos2.y);
// Animate the cube
static float cubeClock = 0;
// Get eye poses, feeding in correct IPD offset
ovrVector3f ViewOffset[2] = { EyeRenderDesc[0].HmdToEyeViewOffset,
EyeRenderDesc[1].HmdToEyeViewOffset };
ovrPosef EyeRenderPose[2];
double ftiming = ovr_GetPredictedDisplayTime(HMD, 0);
// Keeping sensorSampleTime as close to ovr_GetTrackingState as possible - fed into the layer
double sensorSampleTime = ovr_GetTimeInSeconds();
ovrTrackingState hmdState = ovr_GetTrackingState(HMD, ftiming, ovrTrue);
ovr_CalcEyePoses(hmdState.HeadPose.ThePose, ViewOffset, EyeRenderPose);
if (isVisible)
{
for (int eye = 0; eye < 2; ++eye)
{
// Increment to use next texture, just before writing
eyeRenderTexture[eye]->TextureSet->CurrentIndex = (eyeRenderTexture[eye]->TextureSet->CurrentIndex + 1) % eyeRenderTexture[eye]->TextureSet->TextureCount;
// Switch to eye render target
eyeRenderTexture[eye]->SetAndClearRenderSurface(eyeDepthBuffer[eye]);
// Get view and projection matrices
Matrix4f rollPitchYaw = Matrix4f::RotationY(Yaw);
Matrix4f finalRollPitchYaw = rollPitchYaw * Matrix4f(EyeRenderPose[eye].Orientation);
Vector3f finalUp = finalRollPitchYaw.Transform(Vector3f(0, 1, 0));
Vector3f finalForward = finalRollPitchYaw.Transform(Vector3f(0, 0, -1));
Vector3f shiftedEyePos = Pos2 + rollPitchYaw.Transform(EyeRenderPose[eye].Position);
Matrix4f view = Matrix4f::LookAtRH(shiftedEyePos, shiftedEyePos + finalForward, finalUp);
Matrix4f proj = ovrMatrix4f_Projection(hmdDesc.DefaultEyeFov[eye], 0.2f, 1000.0f, ovrProjection_RightHanded);
glm::mat4 view1 = glm::transpose(glm::make_mat4((float *) &view));
glm::mat4 proj1 = glm::transpose(glm::make_mat4((float *) &proj));
/*for (int x = 0; x < 4; x++) {
for (int y = 0; y < 4 y++) {
view1[x][y] = view[x][y];
proj1[x][y] = view[x][y];
}
}*/
scene.render_scene(&opengl, view1, proj1);
// Avoids an error when calling SetAndClearRenderSurface during next iteration.
// Without this, during the next while loop iteration SetAndClearRenderSurface
// would bind a framebuffer with an invalid COLOR_ATTACHMENT0 because the texture ID
// associated with COLOR_ATTACHMENT0 had been unlocked by calling wglDXUnlockObjectsNV.
eyeRenderTexture[eye]->UnsetRenderSurface();
}
}
// Do distortion rendering, Present and flush/sync
// Set up positional data.
ovrViewScaleDesc viewScaleDesc;
viewScaleDesc.HmdSpaceToWorldScaleInMeters = 1.0f;
viewScaleDesc.HmdToEyeViewOffset[0] = ViewOffset[0];
viewScaleDesc.HmdToEyeViewOffset[1] = ViewOffset[1];
ovrLayerEyeFov ld;
ld.Header.Type = ovrLayerType_EyeFov;
ld.Header.Flags = ovrLayerFlag_TextureOriginAtBottomLeft; // Because OpenGL.
for (int eye = 0; eye < 2; ++eye)
{
ld.ColorTexture[eye] = eyeRenderTexture[eye]->TextureSet;
ld.Viewport[eye] = Recti(eyeRenderTexture[eye]->GetSize());
ld.Fov[eye] = hmdDesc.DefaultEyeFov[eye];
ld.RenderPose[eye] = EyeRenderPose[eye];
ld.SensorSampleTime = sensorSampleTime;
}
ovrLayerHeader* layers = &ld.Header;
ovrResult result = ovr_SubmitFrame(HMD, 0, &viewScaleDesc, &layers, 1);
// exit the rendering loop if submit returns an error, will retry on ovrError_DisplayLost
if (!OVR_SUCCESS(result))
goto Done;
isVisible = (result == ovrSuccess);
// Blit mirror texture to back buffer
glBindFramebuffer(GL_READ_FRAMEBUFFER, mirrorFBO);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
GLint w = mirrorTexture->OGL.Header.TextureSize.w;
GLint h = mirrorTexture->OGL.Header.TextureSize.h;
glBlitFramebuffer(0, h, w, 0,
0, 0, w, h,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
SwapBuffers(Platform.hDC);
}
Done:
if (mirrorFBO) glDeleteFramebuffers(1, &mirrorFBO);
if (mirrorTexture) ovr_DestroyMirrorTexture(HMD, reinterpret_cast<ovrTexture*>(mirrorTexture));
for (int eye = 0; eye < 2; ++eye)
{
delete eyeRenderTexture[eye];
delete eyeDepthBuffer[eye];
}
Platform.ReleaseDevice();
ovr_Destroy(HMD);
// Retry on ovrError_DisplayLost
return retryCreate || OVR_SUCCESS(result) || (result == ovrError_DisplayLost);
}
void pixel_tracker_implementation(const PixelEvent & data, std::vector<GpuTrack>& result)
{
num_events = 1;
int num_threads = 0; // auto
debug.setMode(NO_DEBUG);
// debug.setMode(DEBUG);
debug << "Setup:" << endl
<< " Number of threads: " << (num_threads > 0 ? toString<int>(num_threads) : "auto") << endl;
// Deprecated - Now we use PixelEvent and GpuTrack (more civilized)
/* Expected format:
no_sensors - int
no_hits - int
sensor_Zs - no_sensors * int
sensor_hitStarts - no_sensors * int
sensor_hitNums - no_sensors * int
hit_IDs - no_hits * int
hit_Xs - no_hits * double
hit_Ys - no_hits * double
hit_Zs - no_hits * int
*/
/*
no_sensors = (int*) &data;
no_hits = (int*) (no_sensors + 1);
sensor_Zs = (int*) (no_hits + 1);
sensor_hitStarts = (int*) (sensor_Zs + no_sensors[0]);
sensor_hitNums = (int*) (sensor_hitStarts + no_sensors[0]);
hit_IDs = (int*) (sensor_hitNums + no_sensors[0]);
hit_Xs = (double*) (hit_IDs + no_hits[0]);
hit_Ys = (double*) (hit_Xs + no_hits[0]);
hit_Zs = (int*) (hit_Ys + no_hits[0]);
sens_num = no_sensors[0];
hits_num = no_hits[0];
*/
// int noSensors;
// int noHits;
// std::vector<int> sensorZs;
// std::vector<int> sensorHitStarts;
// std::vector<int> sensorHitsNums;
// std::vector<int> hitIDs;
// std::vector<float> hitXs;
// std::vector<float> hitYs;
// std::vector<int> hitZs;
sens_num = data.noSensors;
hits_num = data.noHits;
sensor_Zs = (int*) &data.sensorZs[0];
sensor_hitStarts = (int*) &data.sensorHitStarts[0];
sensor_hitNums = (int*) &data.sensorHitsNums[0];
hit_IDs = (int*) &data.hitIDs[0];
hit_Xs = (float*) &data.hitXs[0];
hit_Ys = (float*) &data.hitYs[0];
hit_Zs = (int*) &data.hitZs[0];
printContentsDump();
// Fill in hit sensorNums info (only needed to cross check results)
fill_hit_sensorNums();
// We need to quicksort
quicksort_the_thing();
printContentsDump();
debug << "Sens num " << sens_num << ", hits num " << hits_num << endl;
// Allocate space for tracks vectors
parallel_tracks_vector.clear();
for (int i=0; i<num_events; ++i) {
vector<GpuTrack> t1;
parallel_tracks_vector.push_back(t1);
}
debug << "Starting parallel searchByPair..." << endl;
// Perform parallel experiments!
if(num_threads > 0)
task_scheduler_init(num_threads);
tick_count parallel_start = tick_count::now();
parallel_for(blocked_range<int>(0, num_events), TBBSearchByPair());
tick_count parallel_end = tick_count::now();
result = parallel_tracks_vector[0];
debug << std::setprecision(3);
debug << "Algorithm execution finished!" << endl
<< "It took: " << (parallel_end - parallel_start).seconds() << " seconds!" << endl;
/* << experiment_timing["mean"] << " seconds (mean), "
<< experiment_timing["deviation"] << " deviation, "
<< experiment_timing["variance"] << " variance, "
<< experiment_timing["min"] << " min, "
<< experiment_timing["max"] << " max " << endl; */
debug << "Testing hits (first GpuTrack): " << endl;
bool all_ok = 1;
for (size_t i = 0; i < hits[0].size(); i++) {
if(hits[0][i] != parallel_tracks_vector[0][0].hits[i]) {
debug << "hit " << i << " differs: " << hits[0][i] << ", " << parallel_tracks_vector[0][0].hits[i] << endl;
all_ok = 0;
}
}
if(all_ok)
debug << " All hits are correct!";
debug << "Writing results..." << endl;
for (int i = 0; i < num_events; i++)
printResultTracks(parallel_tracks_vector[i], i, "parallel_tracks");
debug << "Done!" << endl;
}
void LidarInpaintingHSVTextureVerification(TImage* const originalImage, Mask* const mask,
const unsigned int patchHalfWidth, const unsigned int numberOfKNN,
float slightBlurVariance = 1.0f, unsigned int searchRadius = 1000,
float localRegionSizeMultiplier = 3.0f, float maxAllowedUsedPixelsRatio = 0.5f)
{
itk::ImageRegion<2> fullRegion = originalImage->GetLargestPossibleRegion();
// Extract the RGB image
typedef itk::Image<itk::CovariantVector<float, 3>, 2> RGBImageType;
std::vector<unsigned int> firstThreeChannels = {0,1,2};
RGBImageType::Pointer rgbImage = RGBImageType::New();
ITKHelpers::ExtractChannels(originalImage, firstThreeChannels, rgbImage.GetPointer());
// Create the HSV image
typedef itk::Image<itk::CovariantVector<float, 3>, 2> HSVImageType;
HSVImageType::Pointer hsvImage = HSVImageType::New();
ITKVTKHelpers::ConvertRGBtoHSV(rgbImage.GetPointer(), hsvImage.GetPointer());
ITKHelpers::WriteImage(hsvImage.GetPointer(), "HSVImage.mha");
// Stack the HSV image with the original rest of the channels
typedef itk::Image<itk::CovariantVector<float, 5>, 2> HSVDxDyImageType;
HSVDxDyImageType::Pointer hsvDxDyImage = HSVDxDyImageType::New();
ITKHelpers::DeepCopy(originalImage, hsvDxDyImage.GetPointer());
ITKHelpers::ReplaceChannels(hsvDxDyImage.GetPointer(), firstThreeChannels, hsvImage.GetPointer());
// Blur the image for gradient computation stability (Criminisi's data term)
RGBImageType::Pointer blurredRGBImage = RGBImageType::New();
float blurVariance = 2.0f;
MaskOperations::MaskedBlur(rgbImage.GetPointer(), mask, blurVariance, blurredRGBImage.GetPointer());
ITKHelpers::WriteRGBImage(blurredRGBImage.GetPointer(), "BlurredRGBImage.png");
// Blur the image slightly so that the SSD comparisons are not so noisy
typename HSVDxDyImageType::Pointer slightlyBlurredHSVDxDyImage = TImage::New();
MaskOperations::MaskedBlur(hsvDxDyImage.GetPointer(), mask, slightBlurVariance, slightlyBlurredHSVDxDyImage.GetPointer());
ITKHelpers::WriteImage(slightlyBlurredHSVDxDyImage.GetPointer(), "SlightlyBlurredHSVDxDyImage.mha");
// Create the graph
typedef ImagePatchPixelDescriptor<TImage> ImagePatchPixelDescriptorType;
typedef boost::grid_graph<2> VertexListGraphType;
// We can't make this a signed type (size_t versus int) because we allow negative
boost::array<std::size_t, 2> graphSideLengths = { { fullRegion.GetSize()[0],
fullRegion.GetSize()[1] } };
VertexListGraphType graph(graphSideLengths);
typedef boost::graph_traits<VertexListGraphType>::vertex_descriptor VertexDescriptorType;
typedef boost::graph_traits<VertexListGraphType>::vertex_iterator VertexIteratorType;
// Get the index map
typedef boost::property_map<VertexListGraphType, boost::vertex_index_t>::const_type IndexMapType;
IndexMapType indexMap(get(boost::vertex_index, graph));
// Create the descriptor map. This is where the data for each pixel is stored.
typedef boost::vector_property_map<ImagePatchPixelDescriptorType, IndexMapType> ImagePatchDescriptorMapType;
ImagePatchDescriptorMapType imagePatchDescriptorMap(num_vertices(graph), indexMap);
// Create the patch inpainter.
typedef PatchInpainter<TImage> OriginalImageInpainterType;
OriginalImageInpainterType originalImagePatchInpainter(patchHalfWidth, originalImage, mask);
originalImagePatchInpainter.SetDebugImages(true);
originalImagePatchInpainter.SetImageName("RGB");
// Create an inpainter for the HSV image.
typedef PatchInpainter<HSVImageType> HSVImageInpainterType;
HSVImageInpainterType hsvImagePatchInpainter(patchHalfWidth, hsvImage, mask);
// Create an inpainter for the RGB image.
typedef PatchInpainter<RGBImageType> RGBImageInpainterType;
RGBImageInpainterType rgbImagePatchInpainter(patchHalfWidth, rgbImage, mask);
// Create an inpainter for the blurred image.
typedef PatchInpainter<RGBImageType> BlurredImageInpainterType;
BlurredImageInpainterType blurredRGBImagePatchInpainter(patchHalfWidth, blurredRGBImage, mask);
// Create an inpainter for the slightly blurred image.
typedef PatchInpainter<TImage> SlightlyBlurredHSVDxDyImageImageInpainterType;
SlightlyBlurredHSVDxDyImageImageInpainterType slightlyBlurredHSVDxDyImageImagePatchInpainter(patchHalfWidth, slightlyBlurredHSVDxDyImage, mask);
// Create a composite inpainter. (Note: the mask is inpainted in InpaintingVisitor::FinishVertex)
CompositePatchInpainter inpainter;
inpainter.AddInpainter(&originalImagePatchInpainter);
inpainter.AddInpainter(&hsvImagePatchInpainter);
inpainter.AddInpainter(&blurredRGBImagePatchInpainter);
inpainter.AddInpainter(&slightlyBlurredHSVDxDyImageImagePatchInpainter);
inpainter.AddInpainter(&rgbImagePatchInpainter);
// Create the priority function
typedef PriorityCriminisi<RGBImageType> PriorityType;
PriorityType priorityFunction(blurredRGBImage, mask, patchHalfWidth);
// priorityFunction.SetDebugLevel(1);
// Queue
typedef IndirectPriorityQueue<VertexListGraphType> BoundaryNodeQueueType;
BoundaryNodeQueueType boundaryNodeQueue(graph);
// Create the descriptor visitor (used for SSD comparisons).
typedef ImagePatchDescriptorVisitor<VertexListGraphType, TImage, ImagePatchDescriptorMapType>
ImagePatchDescriptorVisitorType;
// ImagePatchDescriptorVisitorType imagePatchDescriptorVisitor(originalImage, mask,
// imagePatchDescriptorMap, patchHalfWidth); // Use the non-blurred image for the SSD comparisons
ImagePatchDescriptorVisitorType imagePatchDescriptorVisitor(slightlyBlurredHSVDxDyImage, mask,
imagePatchDescriptorMap, patchHalfWidth); // Use the slightly blurred HSV image for the SSD comparisons. Make sure to use a *HSVSSD difference functor so the H differences are treated appropriately!
typedef DefaultAcceptanceVisitor<VertexListGraphType> AcceptanceVisitorType;
AcceptanceVisitorType acceptanceVisitor;
// Create the inpainting visitor. (The mask is inpainted in FinishVertex)
typedef InpaintingVisitor<VertexListGraphType, BoundaryNodeQueueType,
ImagePatchDescriptorVisitorType, AcceptanceVisitorType, PriorityType, TImage>
InpaintingVisitorType;
InpaintingVisitorType inpaintingVisitor(mask, boundaryNodeQueue,
imagePatchDescriptorVisitor, acceptanceVisitor,
&priorityFunction, patchHalfWidth, "InpaintingVisitor", originalImage);
inpaintingVisitor.SetDebugImages(true); // This produces PatchesCopied* images showing where patches were copied from/to at each iteration
// inpaintingVisitor.SetAllowNewPatches(false);
inpaintingVisitor.SetAllowNewPatches(true); // we can do this as long as we use one of the LinearSearchKNNProperty*Reuse (like LinearSearchKNNPropertyLimitLocalReuse) in the steps below
InitializePriority(mask, boundaryNodeQueue, &priorityFunction);
// Initialize the boundary node queue from the user provided mask image.
InitializeFromMaskImage<InpaintingVisitorType, VertexDescriptorType>(mask, &inpaintingVisitor);
std::cout << "PatchBasedInpaintingNonInteractive: There are " << boundaryNodeQueue.CountValidNodes()
<< " nodes in the boundaryNodeQueue" << std::endl;
#define DUseWeightedDifference
#ifdef DUseWeightedDifference
// The absolute value of the depth derivative range is usually about [0,12], so to make
// it comparable to to the color image channel range of [0,255], we multiply by 255/12 ~= 20.
// float depthDerivativeWeight = 20.0f;
// This should not be computed "by eye" by looking at the Dx and Dy channels of the PTX scan, because there are typically
// huge depth discontinuties around the objects that are going to be inpainted. We'd have to look at the masked version of this
// image to determine the min/max values of the unmasked pixels. They will be much smaller than the min/max values of the original
// image, which will make the depth derivative weights much higher (~100 or so)
// std::vector<typename TImage::PixelType> channelMins = ITKHelpers::ComputeMinOfAllChannels(originalImage);
// std::vector<typename TImage::PixelType> channelMaxs = ITKHelpers::ComputeMaxOfAllChannels(originalImage);
typename TImage::PixelType channelMins;
ITKHelpers::ComputeMinOfAllChannels(originalImage, channelMins);
typename TImage::PixelType channelMaxs;
ITKHelpers::ComputeMaxOfAllChannels(originalImage, channelMaxs);
float minX = fabs(channelMins[3]);
float maxX = fabs(channelMaxs[3]);
float maxValueX = std::max(minX, maxX);
std::cout << "maxValueX = " << maxValueX << std::endl;
float depthDerivativeWeightX = 255.0f / maxValueX;
std::cout << "Computed depthDerivativeWeightX = " << depthDerivativeWeightX << std::endl;
float minY = fabs(channelMins[4]);
float maxY = fabs(channelMaxs[4]);
float maxValueY = std::max(minY, maxY);
std::cout << "maxValueY = " << maxValueY << std::endl;
float depthDerivativeWeightY = 255.0f / maxValueY;
std::cout << "Computed depthDerivativeWeightY = " << depthDerivativeWeightY << std::endl;
// Use all channels
std::vector<float> weights = {1.0f, 1.0f, 1.0f, depthDerivativeWeightX, depthDerivativeWeightY};
// typedef WeightedSumSquaredPixelDifference<typename TImage::PixelType> PixelDifferenceType;
typedef WeightedHSVSSDFull<typename TImage::PixelType> FullPixelDifferenceType;
FullPixelDifferenceType fullPixelDifferenceFunctor(weights);
typedef ImagePatchDifference<ImagePatchPixelDescriptorType,
FullPixelDifferenceType > FullPatchDifferenceType;
FullPatchDifferenceType fullPatchDifferenceFunctor(fullPixelDifferenceFunctor);
// Use only the first 3 channels
typedef HSVSSD<typename TImage::PixelType> First3PixelDifferenceType;
First3PixelDifferenceType first3PixelDifferenceFunctor;
typedef ImagePatchDifference<ImagePatchPixelDescriptorType,
First3PixelDifferenceType > First3PatchDifferenceType;
First3PatchDifferenceType first3PatchDifferenceFunctor(first3PixelDifferenceFunctor);
#else
// Use an unweighted pixel difference
typedef ImagePatchDifference<ImagePatchPixelDescriptorType,
SumSquaredPixelDifference<typename TImage::PixelType> > PatchDifferenceType;
PatchDifferenceType patchDifferenceFunctor;
#endif
//#define DAllowReuse // comment/uncomment this line to toggle allowing patches to be used as the source patch more than once
#ifdef DAllowReuse
// Create the first (KNN) neighbor finder
typedef LinearSearchKNNProperty<ImagePatchDescriptorMapType, PatchDifferenceType> KNNSearchType;
KNNSearchType linearSearchKNN(imagePatchDescriptorMap, numberOfKNN, patchDifferenceFunctor);
#else
typedef LinearSearchKNNPropertyLimitLocalReuse<ImagePatchDescriptorMapType, FullPatchDifferenceType, RGBImageType> KNNSearchType;
KNNSearchType linearSearchKNN(imagePatchDescriptorMap, mask, numberOfKNN, localRegionSizeMultiplier, maxAllowedUsedPixelsRatio,
fullPatchDifferenceFunctor, inpaintingVisitor.GetSourcePixelMapImage(),
rgbImage.GetPointer());
linearSearchKNN.SetDebugImages(true);
linearSearchKNN.SetDebugScreenOutputs(true);
#endif
//#else // This works the best, but is less useful for demonstrations
// typedef LinearSearchKNNPropertyLimitLocalReuse<ImagePatchDescriptorMapType, FullPatchDifferenceType, RGBImageType> FullPixelKNNSearchType;
// FullPixelKNNSearchType fullPixelSearchKNN(imagePatchDescriptorMap, mask, numberOfKNN, localRegionSizeMultiplier, maxAllowedUsedPixelsRatio,
// fullPatchDifferenceFunctor, inpaintingVisitor.GetSourcePixelMapImage(),
// rgbImage.GetPointer());
// fullPixelSearchKNN.SetDebugImages(true);
// fullPixelSearchKNN.SetDebugScreenOutputs(true);
// typedef LinearSearchKNNPropertyLimitLocalReuse<ImagePatchDescriptorMapType, First3PatchDifferenceType, RGBImageType> First3PixelKNNSearchType;
// First3PixelKNNSearchType first3SearchKNN(imagePatchDescriptorMap, mask, numberOfKNN, localRegionSizeMultiplier, maxAllowedUsedPixelsRatio,
// first3PatchDifferenceFunctor, inpaintingVisitor.GetSourcePixelMapImage(),
// rgbImage.GetPointer());
// first3SearchKNN.SetDebugScreenOutputs(true);
//// typedef LinearSearchKNNProperty<ImagePatchDescriptorMapType, First3PatchDifferenceType> First3PixelKNNSearchType;
//// First3PixelKNNSearchType first3SearchKNN(imagePatchDescriptorMap, numberOfKNN,
//// first3PatchDifferenceFunctor);
//// first3SearchKNN.SetDebugImages(true);
// typedef LinearSearchKNNPropertyCombine<FullPixelKNNSearchType, First3PixelKNNSearchType> KNNSearchType;
// KNNSearchType linearSearchKNN(fullPixelSearchKNN, first3SearchKNN);
//#endif
// Setup the second (1-NN) neighbor finder
typedef std::vector<VertexDescriptorType>::iterator VertexDescriptorVectorIteratorType;
// This is templated on TImage because we need it to write out debug patches from this searcher (since we are not using an RGB image to compute the histograms)
// typedef LinearSearchBestTexture<ImagePatchDescriptorMapType, HSVImageType,
// VertexDescriptorVectorIteratorType, TImage> BestSearchType; // Use the histogram of the gradient magnitudes of a scalar represetnation of the image (e.g. magnitude image)
// typedef LinearSearchBestLidarTextureDerivatives<ImagePatchDescriptorMapType, HSVImageType,
// VertexDescriptorVectorIteratorType, TImage> BestSearchType; // Use the concatenated histograms of the absolute value of the derivatives of each channel
// typedef LinearSearchBestLidarHSVTextureGradient<ImagePatchDescriptorMapType, HSVDxDyImageType,
// VertexDescriptorVectorIteratorType, RGBImageType> BestSearchType; // Use the concatenated histograms of the gradient magnitudes of each channel. This HSVDxDyImageType must match the hsvDxDyImage provided below
typedef LinearSearchBestLidarHSVTextureGradientWithSort<ImagePatchDescriptorMapType, HSVDxDyImageType,
VertexDescriptorVectorIteratorType, RGBImageType> BestSearchType; // Use the concatenated histograms of the gradient magnitudes of each channel. This HSVDxDyImageType must match the hsvDxDyImage provided below. Also sort the patches for demonstrative output purposes.
// BestSearchType linearSearchBest(imagePatchDescriptorMap, hsvDxDyImage.GetPointer(), mask); // use non-blurred for texture sorting
Debug bestSearchTypeDebug;
bestSearchTypeDebug.SetDebugScreenOutputs(true);
// bestSearchTypeDebug.SetDebugImages(true);
// linearSearchBest.SetDebugOutputs(true);
// linearSearchBest.SetDebugImages(true);
// use slightly blurred for texture sorting
BestSearchType linearSearchBest(imagePatchDescriptorMap, slightlyBlurredHSVDxDyImage.GetPointer(),
mask, rgbImage.GetPointer(), bestSearchTypeDebug);
// linearSearchBest.SetDebugImages(false);
linearSearchBest.SetDebugImages(true); // This produces BestPatch* images showing the list of the top K patches that were passed to the BestSearch functor
// Setup the two step neighbor finder
TwoStepNearestNeighbor<KNNSearchType, BestSearchType>
twoStepNearestNeighbor(linearSearchKNN, linearSearchBest);
// #define DFullSearch // comment/uncomment this line to set the search region
#ifdef DFullSearch
// Perform the inpainting (full search)
InpaintingAlgorithm(graph, inpaintingVisitor, &boundaryNodeQueue,
twoStepNearestNeighbor, &inpainter);
#else
NeighborhoodSearch<VertexDescriptorType, ImagePatchDescriptorMapType> neighborhoodSearch(originalImage->GetLargestPossibleRegion(),
searchRadius, imagePatchDescriptorMap);
// Perform the inpainting (local search)
bool algorithmDebug = true;
InpaintingAlgorithmWithLocalSearch(graph, inpaintingVisitor, &boundaryNodeQueue,
twoStepNearestNeighbor, &inpainter, neighborhoodSearch, algorithmDebug);
#endif
}
inline void debug_ast(AST_Node* node, std::string ind, Env* env)
{
if (node == 0) return;
if (ind == "") std::cerr << "####################################################################\n";
if (dynamic_cast<Bubble*>(node)) {
Bubble* bubble = dynamic_cast<Bubble*>(node);
std::cerr << ind << "Bubble " << bubble;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << bubble->tabs();
std::cerr << std::endl;
} else if (dynamic_cast<At_Root_Block*>(node)) {
At_Root_Block* root_block = dynamic_cast<At_Root_Block*>(node);
std::cerr << ind << "At_Root_Block " << root_block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << root_block->tabs();
std::cerr << std::endl;
debug_ast(root_block->expression(), ind + ":", env);
debug_ast(root_block->block(), ind + " ", env);
} else if (dynamic_cast<Selector_List*>(node)) {
Selector_List* selector = dynamic_cast<Selector_List*>(node);
std::cerr << ind << "Selector_List " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " [@media:" << selector->media_block() << "]";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
// } else if (dynamic_cast<Expression*>(node)) {
// Expression* expression = dynamic_cast<Expression*>(node);
// std::cerr << ind << "Expression " << expression << " " << expression->concrete_type() << std::endl;
} else if (dynamic_cast<Parent_Selector*>(node)) {
Parent_Selector* selector = dynamic_cast<Parent_Selector*>(node);
std::cerr << ind << "Parent_Selector " << selector;
// if (selector->not_selector()) cerr << " [in_declaration]";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
// debug_ast(selector->selector(), ind + "->", env);
} else if (dynamic_cast<Complex_Selector*>(node)) {
Complex_Selector* selector = dynamic_cast<Complex_Selector*>(node);
std::cerr << ind << "Complex_Selector " << selector
<< " (" << pstate_source_position(node) << ")"
<< " <" << selector->hash() << ">"
<< " [weight:" << longToHex(selector->specificity()) << "]"
<< " [@media:" << selector->media_block() << "]"
<< (selector->is_optional() ? " [is_optional]": " -")
<< (selector->has_parent_ref() ? " [has parent]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< (selector->has_line_break() ? " [line-break]": " -")
<< " -- ";
std::string del;
switch (selector->combinator()) {
case Complex_Selector::PARENT_OF: del = ">"; break;
case Complex_Selector::PRECEDES: del = "~"; break;
case Complex_Selector::ADJACENT_TO: del = "+"; break;
case Complex_Selector::ANCESTOR_OF: del = " "; break;
case Complex_Selector::REFERENCE: del = "//"; break;
}
// if (del = "/") del += selector->reference()->perform(&to_string) + "/";
std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
debug_ast(selector->head(), ind + " " /* + "[" + del + "]" */, env);
if (selector->tail()) {
debug_ast(selector->tail(), ind + "{" + del + "}", env);
} else if(del != " ") {
std::cerr << ind << " |" << del << "| {trailing op}" << std::endl;
}
SourcesSet set = selector->sources();
// debug_sources_set(set, ind + " @--> ");
} else if (dynamic_cast<Compound_Selector*>(node)) {
Compound_Selector* selector = dynamic_cast<Compound_Selector*>(node);
std::cerr << ind << "Compound_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " [weight:" << longToHex(selector->specificity()) << "]";
std::cerr << " [@media:" << selector->media_block() << "]";
std::cerr << (selector->extended() ? " [extended]": " -");
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << std::endl;
for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Propset*>(node)) {
Propset* selector = dynamic_cast<Propset*>(node);
std::cerr << ind << "Propset " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << selector->tabs() << std::endl;
if (selector->block()) for(auto i : selector->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Wrapped_Selector*>(node)) {
Wrapped_Selector* selector = dynamic_cast<Wrapped_Selector*>(node);
std::cerr << ind << "Wrapped_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
debug_ast(selector->selector(), ind + " () ", env);
} else if (dynamic_cast<Pseudo_Selector*>(node)) {
Pseudo_Selector* selector = dynamic_cast<Pseudo_Selector*>(node);
std::cerr << ind << "Pseudo_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
debug_ast(selector->expression(), ind + " <= ", env);
} else if (dynamic_cast<Attribute_Selector*>(node)) {
Attribute_Selector* selector = dynamic_cast<Attribute_Selector*>(node);
std::cerr << ind << "Attribute_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
debug_ast(selector->value(), ind + "[" + selector->matcher() + "] ", env);
} else if (dynamic_cast<Selector_Qualifier*>(node)) {
Selector_Qualifier* selector = dynamic_cast<Selector_Qualifier*>(node);
std::cerr << ind << "Selector_Qualifier " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << std::endl;
} else if (dynamic_cast<Type_Selector*>(node)) {
Type_Selector* selector = dynamic_cast<Type_Selector*>(node);
std::cerr << ind << "Type_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <" << selector->hash() << ">";
std::cerr << " <<" << selector->ns_name() << ">>";
std::cerr << (selector->is_optional() ? " [is_optional]": " -");
std::cerr << (selector->has_parent_ref() ? " [has-parent]": " -");
std::cerr << (selector->has_line_break() ? " [line-break]": " -");
std::cerr << (selector->has_line_feed() ? " [line-feed]": " -");
std::cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">";
std::cerr << std::endl;
} else if (dynamic_cast<Selector_Placeholder*>(node)) {
Selector_Placeholder* selector = dynamic_cast<Selector_Placeholder*>(node);
std::cerr << ind << "Selector_Placeholder [" << selector->ns_name() << "] " << selector
<< " <" << selector->hash() << ">"
<< " [@media:" << selector->media_block() << "]"
<< (selector->is_optional() ? " [is_optional]": " -")
<< (selector->has_line_break() ? " [line-break]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< std::endl;
} else if (dynamic_cast<Simple_Selector*>(node)) {
Simple_Selector* selector = dynamic_cast<Simple_Selector*>(node);
std::cerr << ind << "Simple_Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << (selector->has_line_break() ? " [line-break]": " -") << (selector->has_line_feed() ? " [line-feed]": " -") << std::endl;
} else if (dynamic_cast<Selector_Schema*>(node)) {
Selector_Schema* selector = dynamic_cast<Selector_Schema*>(node);
std::cerr << ind << "Selector_Schema " << selector;
std::cerr << " (" << pstate_source_position(node) << ")"
<< (selector->at_root() && selector->at_root() ? " [@ROOT]" : "")
<< " [@media:" << selector->media_block() << "]"
<< (selector->has_line_break() ? " [line-break]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< std::endl;
debug_ast(selector->contents(), ind + " ");
// for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Selector*>(node)) {
Selector* selector = dynamic_cast<Selector*>(node);
std::cerr << ind << "Selector " << selector;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << (selector->has_line_break() ? " [line-break]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< std::endl;
} else if (dynamic_cast<Media_Query_Expression*>(node)) {
Media_Query_Expression* block = dynamic_cast<Media_Query_Expression*>(node);
std::cerr << ind << "Media_Query_Expression " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << (block->is_interpolated() ? " [is_interpolated]": " -")
<< std::endl;
debug_ast(block->feature(), ind + " feature) ");
debug_ast(block->value(), ind + " value) ");
} else if (dynamic_cast<Media_Query*>(node)) {
Media_Query* block = dynamic_cast<Media_Query*>(node);
std::cerr << ind << "Media_Query " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << (block->is_negated() ? " [is_negated]": " -")
<< (block->is_restricted() ? " [is_restricted]": " -")
<< std::endl;
debug_ast(block->media_type(), ind + " ");
for(auto i : block->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Media_Block*>(node)) {
Media_Block* block = dynamic_cast<Media_Block*>(node);
std::cerr << ind << "Media_Block " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->media_queries(), ind + " =@ ");
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Supports_Block*>(node)) {
Supports_Block* block = dynamic_cast<Supports_Block*>(node);
std::cerr << ind << "Supports_Block " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->condition(), ind + " =@ ");
} else if (dynamic_cast<Supports_Operator*>(node)) {
Supports_Operator* block = dynamic_cast<Supports_Operator*>(node);
std::cerr << ind << "Supports_Operator " << block;
std::cerr << " (" << pstate_source_position(node) << ")"
<< std::endl;
debug_ast(block->left(), ind + " left) ");
debug_ast(block->right(), ind + " right) ");
} else if (dynamic_cast<Supports_Negation*>(node)) {
Supports_Negation* block = dynamic_cast<Supports_Negation*>(node);
std::cerr << ind << "Supports_Negation " << block;
std::cerr << " (" << pstate_source_position(node) << ")"
<< std::endl;
debug_ast(block->condition(), ind + " condition) ");
} else if (dynamic_cast<Supports_Declaration*>(node)) {
Supports_Declaration* block = dynamic_cast<Supports_Declaration*>(node);
std::cerr << ind << "Supports_Declaration " << block;
std::cerr << " (" << pstate_source_position(node) << ")"
<< std::endl;
debug_ast(block->feature(), ind + " feature) ");
debug_ast(block->value(), ind + " value) ");
} else if (dynamic_cast<Block*>(node)) {
Block* root_block = dynamic_cast<Block*>(node);
std::cerr << ind << "Block " << root_block;
std::cerr << " (" << pstate_source_position(node) << ")";
if (root_block->is_root()) std::cerr << " [root]";
std::cerr << " " << root_block->tabs() << std::endl;
if (root_block->block()) for(auto i : root_block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Warning*>(node)) {
Warning* block = dynamic_cast<Warning*>(node);
std::cerr << ind << "Warning " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Error*>(node)) {
Error* block = dynamic_cast<Error*>(node);
std::cerr << ind << "Error " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Debug*>(node)) {
Debug* block = dynamic_cast<Debug*>(node);
std::cerr << ind << "Debug " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Comment*>(node)) {
Comment* block = dynamic_cast<Comment*>(node);
std::cerr << ind << "Comment " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() <<
" <" << prettyprint(block->pstate().token.ws_before()) << ">" << std::endl;
debug_ast(block->text(), ind + "// ", env);
} else if (dynamic_cast<If*>(node)) {
If* block = dynamic_cast<If*>(node);
std::cerr << ind << "If " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->predicate(), ind + " = ");
debug_ast(block->block(), ind + " <>");
debug_ast(block->alternative(), ind + " ><");
} else if (dynamic_cast<Return*>(node)) {
Return* block = dynamic_cast<Return*>(node);
std::cerr << ind << "Return " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Extension*>(node)) {
Extension* block = dynamic_cast<Extension*>(node);
std::cerr << ind << "Extension " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->selector(), ind + "-> ", env);
} else if (dynamic_cast<Content*>(node)) {
Content* block = dynamic_cast<Content*>(node);
std::cerr << ind << "Content " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Import_Stub*>(node)) {
Import_Stub* block = dynamic_cast<Import_Stub*>(node);
std::cerr << ind << "Import_Stub " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
} else if (dynamic_cast<Import*>(node)) {
Import* block = dynamic_cast<Import*>(node);
std::cerr << ind << "Import " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->media_queries(), ind + " @ ");
// std::vector<std::string> files_;
for (auto imp : block->urls()) debug_ast(imp, "@ ", env);
} else if (dynamic_cast<Assignment*>(node)) {
Assignment* block = dynamic_cast<Assignment*>(node);
std::cerr << ind << "Assignment " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " <<" << block->variable() << ">> " << block->tabs() << std::endl;
debug_ast(block->value(), ind + "=", env);
} else if (dynamic_cast<Declaration*>(node)) {
Declaration* block = dynamic_cast<Declaration*>(node);
std::cerr << ind << "Declaration " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->property(), ind + " prop: ", env);
debug_ast(block->value(), ind + " value: ", env);
} else if (dynamic_cast<Keyframe_Rule*>(node)) {
Keyframe_Rule* has_block = dynamic_cast<Keyframe_Rule*>(node);
std::cerr << ind << "Keyframe_Rule " << has_block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << has_block->tabs() << std::endl;
if (has_block->selector()) debug_ast(has_block->selector(), ind + "@");
if (has_block->block()) for(auto i : has_block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<At_Rule*>(node)) {
At_Rule* block = dynamic_cast<At_Rule*>(node);
std::cerr << ind << "At_Rule " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << block->keyword() << "] " << block->tabs() << std::endl;
debug_ast(block->selector(), ind + "~", env);
debug_ast(block->value(), ind + "+", env);
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Each*>(node)) {
Each* block = dynamic_cast<Each*>(node);
std::cerr << ind << "Each " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<For*>(node)) {
For* block = dynamic_cast<For*>(node);
std::cerr << ind << "For " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<While*>(node)) {
While* block = dynamic_cast<While*>(node);
std::cerr << ind << "While " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << block->tabs() << std::endl;
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Definition*>(node)) {
Definition* block = dynamic_cast<Definition*>(node);
std::cerr << ind << "Definition " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [name: " << block->name() << "] ";
std::cerr << " [type: " << (block->type() == Sass::Definition::Type::MIXIN ? "Mixin " : "Function ") << "] ";
// this seems to lead to segfaults some times?
// std::cerr << " [signature: " << block->signature() << "] ";
std::cerr << " [native: " << block->native_function() << "] ";
std::cerr << " " << block->tabs() << std::endl;
debug_ast(block->parameters(), ind + " params: ", env);
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Mixin_Call*>(node)) {
Mixin_Call* block = dynamic_cast<Mixin_Call*>(node);
std::cerr << ind << "Mixin_Call " << block << " " << block->tabs();
std::cerr << " [" << block->name() << "]";
std::cerr << " [has_content: " << block->has_content() << "] " << std::endl;
debug_ast(block->arguments(), ind + " args: ");
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (Ruleset* ruleset = dynamic_cast<Ruleset*>(node)) {
std::cerr << ind << "Ruleset " << ruleset;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [indent: " << ruleset->tabs() << "]";
std::cerr << (ruleset->at_root() ? " [@ROOT]" : "");
std::cerr << (ruleset->is_root() ? " [root]" : "");
std::cerr << std::endl;
debug_ast(ruleset->selector(), ind + ">");
debug_ast(ruleset->block(), ind + " ");
} else if (dynamic_cast<Block*>(node)) {
Block* block = dynamic_cast<Block*>(node);
std::cerr << ind << "Block " << block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [indent: " << block->tabs() << "]" << std::endl;
for(auto i : block->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Textual*>(node)) {
Textual* expression = dynamic_cast<Textual*>(node);
std::cerr << ind << "Textual ";
if (expression->type() == Textual::NUMBER) std::cerr << " [NUMBER]";
else if (expression->type() == Textual::PERCENTAGE) std::cerr << " [PERCENTAGE]";
else if (expression->type() == Textual::DIMENSION) std::cerr << " [DIMENSION]";
else if (expression->type() == Textual::HEX) std::cerr << " [HEX]";
std::cerr << expression << " [" << expression->value() << "]";
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
if (expression->is_delayed()) std::cerr << " [delayed]";
std::cerr << std::endl;
} else if (dynamic_cast<Variable*>(node)) {
Variable* expression = dynamic_cast<Variable*>(node);
std::cerr << ind << "Variable " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->name() << "]" << std::endl;
std::string name(expression->name());
if (env && env->has(name)) debug_ast(static_cast<Expression*>((*env)[name]), ind + " -> ", env);
} else if (dynamic_cast<Function_Call_Schema*>(node)) {
Function_Call_Schema* expression = dynamic_cast<Function_Call_Schema*>(node);
std::cerr << ind << "Function_Call_Schema " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << "" << std::endl;
debug_ast(expression->name(), ind + "name: ", env);
debug_ast(expression->arguments(), ind + " args: ", env);
} else if (dynamic_cast<Function_Call*>(node)) {
Function_Call* expression = dynamic_cast<Function_Call*>(node);
std::cerr << ind << "Function_Call " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->name() << "]";
if (expression->is_delayed()) std::cerr << " [delayed]";
if (expression->is_interpolant()) std::cerr << " [interpolant]";
std::cerr << std::endl;
debug_ast(expression->arguments(), ind + " args: ", env);
} else if (dynamic_cast<Arguments*>(node)) {
Arguments* expression = dynamic_cast<Arguments*>(node);
std::cerr << ind << "Arguments " << expression;
if (expression->is_delayed()) std::cerr << " [delayed]";
std::cerr << " (" << pstate_source_position(node) << ")";
if (expression->has_named_arguments()) std::cerr << " [has_named_arguments]";
if (expression->has_rest_argument()) std::cerr << " [has_rest_argument]";
if (expression->has_keyword_argument()) std::cerr << " [has_keyword_argument]";
std::cerr << std::endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Argument*>(node)) {
Argument* expression = dynamic_cast<Argument*>(node);
std::cerr << ind << "Argument " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->value() << "]";
std::cerr << " [name: " << expression->name() << "] ";
std::cerr << " [rest: " << expression->is_rest_argument() << "] ";
std::cerr << " [keyword: " << expression->is_keyword_argument() << "] " << std::endl;
debug_ast(expression->value(), ind + " value: ", env);
} else if (dynamic_cast<Parameters*>(node)) {
Parameters* expression = dynamic_cast<Parameters*>(node);
std::cerr << ind << "Parameters " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [has_optional: " << expression->has_optional_parameters() << "] ";
std::cerr << " [has_rest: " << expression->has_rest_parameter() << "] ";
std::cerr << std::endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Parameter*>(node)) {
Parameter* expression = dynamic_cast<Parameter*>(node);
std::cerr << ind << "Parameter " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [name: " << expression->name() << "] ";
std::cerr << " [default: " << expression->default_value() << "] ";
std::cerr << " [rest: " << expression->is_rest_parameter() << "] " << std::endl;
} else if (dynamic_cast<Unary_Expression*>(node)) {
Unary_Expression* expression = dynamic_cast<Unary_Expression*>(node);
std::cerr << ind << "Unary_Expression " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->type() << "]" << std::endl;
debug_ast(expression->operand(), ind + " operand: ", env);
} else if (dynamic_cast<Binary_Expression*>(node)) {
Binary_Expression* expression = dynamic_cast<Binary_Expression*>(node);
std::cerr << ind << "Binary_Expression " << expression;
if (expression->is_interpolant()) std::cerr << " [is interpolant] ";
if (expression->is_left_interpolant()) std::cerr << " [left interpolant] ";
if (expression->is_right_interpolant()) std::cerr << " [right interpolant] ";
std::cerr << " [delayed: " << expression->is_delayed() << "] ";
std::cerr << " [ws_before: " << expression->op().ws_before << "] ";
std::cerr << " [ws_after: " << expression->op().ws_after << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << expression->type_name() << "]" << std::endl;
debug_ast(expression->left(), ind + " left: ", env);
debug_ast(expression->right(), ind + " right: ", env);
} else if (dynamic_cast<Map*>(node)) {
Map* expression = dynamic_cast<Map*>(node);
std::cerr << ind << "Map " << expression;
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [Hashed]" << std::endl;
for (auto i : expression->elements()) {
debug_ast(i.first, ind + " key: ");
debug_ast(i.second, ind + " val: ");
}
} else if (dynamic_cast<List*>(node)) {
List* expression = dynamic_cast<List*>(node);
std::cerr << ind << "List " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " (" << expression->length() << ") " <<
(expression->separator() == SASS_COMMA ? "Comma " : expression->separator() == SASS_HASH ? "Map" : "Space ") <<
" [delayed: " << expression->is_delayed() << "] " <<
" [interpolant: " << expression->is_interpolant() << "] " <<
" [arglist: " << expression->is_arglist() << "] " <<
" [hash: " << expression->hash() << "] " <<
std::endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Content*>(node)) {
Content* expression = dynamic_cast<Content*>(node);
std::cerr << ind << "Content " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [Statement]" << std::endl;
} else if (dynamic_cast<Boolean*>(node)) {
Boolean* expression = dynamic_cast<Boolean*>(node);
std::cerr << ind << "Boolean " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " [" << expression->value() << "]" << std::endl;
} else if (dynamic_cast<Color*>(node)) {
Color* expression = dynamic_cast<Color*>(node);
std::cerr << ind << "Color " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " [" << expression->r() << ":" << expression->g() << ":" << expression->b() << "@" << expression->a() << "]" << std::endl;
} else if (dynamic_cast<Number*>(node)) {
Number* expression = dynamic_cast<Number*>(node);
std::cerr << ind << "Number " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [interpolant: " << expression->is_interpolant() << "] ";
std::cerr << " [" << expression->value() << expression->unit() << "]" <<
" [hash: " << expression->hash() << "] " <<
std::endl;
} else if (dynamic_cast<String_Quoted*>(node)) {
String_Quoted* expression = dynamic_cast<String_Quoted*>(node);
std::cerr << ind << "String_Quoted " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << prettyprint(expression->value()) << "]";
if (expression->is_delayed()) std::cerr << " [delayed]";
if (expression->sass_fix_1291()) std::cerr << " [sass_fix_1291]";
if (expression->is_interpolant()) std::cerr << " [interpolant]";
if (expression->quote_mark()) std::cerr << " [quote_mark: " << expression->quote_mark() << "]";
std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
} else if (dynamic_cast<String_Constant*>(node)) {
String_Constant* expression = dynamic_cast<String_Constant*>(node);
std::cerr << ind << "String_Constant " << expression;
if (expression->concrete_type()) {
std::cerr << " " << expression->concrete_type();
}
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " [" << prettyprint(expression->value()) << "]";
if (expression->is_delayed()) std::cerr << " [delayed]";
if (expression->sass_fix_1291()) std::cerr << " [sass_fix_1291]";
if (expression->is_interpolant()) std::cerr << " [interpolant]";
std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
} else if (dynamic_cast<String_Schema*>(node)) {
String_Schema* expression = dynamic_cast<String_Schema*>(node);
std::cerr << ind << "String_Schema " << expression;
std::cerr << " " << expression->concrete_type();
if (expression->is_delayed()) std::cerr << " [delayed]";
if (expression->is_interpolant()) std::cerr << " [is interpolant]";
if (expression->has_interpolant()) std::cerr << " [has interpolant]";
if (expression->is_left_interpolant()) std::cerr << " [left interpolant] ";
if (expression->is_right_interpolant()) std::cerr << " [right interpolant] ";
std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<String*>(node)) {
String* expression = dynamic_cast<String*>(node);
std::cerr << ind << "String " << expression;
std::cerr << " " << expression->concrete_type();
std::cerr << " (" << pstate_source_position(node) << ")";
if (expression->sass_fix_1291()) std::cerr << " [sass_fix_1291]";
if (expression->is_interpolant()) std::cerr << " [interpolant]";
std::cerr << " <" << prettyprint(expression->pstate().token.ws_before()) << ">" << std::endl;
} else if (dynamic_cast<Expression*>(node)) {
Expression* expression = dynamic_cast<Expression*>(node);
std::cerr << ind << "Expression " << expression;
std::cerr << " (" << pstate_source_position(node) << ")";
switch (expression->concrete_type()) {
case Expression::Concrete_Type::NONE: std::cerr << " [NONE]"; break;
case Expression::Concrete_Type::BOOLEAN: std::cerr << " [BOOLEAN]"; break;
case Expression::Concrete_Type::NUMBER: std::cerr << " [NUMBER]"; break;
case Expression::Concrete_Type::COLOR: std::cerr << " [COLOR]"; break;
case Expression::Concrete_Type::STRING: std::cerr << " [STRING]"; break;
case Expression::Concrete_Type::LIST: std::cerr << " [LIST]"; break;
case Expression::Concrete_Type::MAP: std::cerr << " [MAP]"; break;
case Expression::Concrete_Type::SELECTOR: std::cerr << " [SELECTOR]"; break;
case Expression::Concrete_Type::NULL_VAL: std::cerr << " [NULL_VAL]"; break;
case Expression::Concrete_Type::C_WARNING: std::cerr << " [C_WARNING]"; break;
case Expression::Concrete_Type::C_ERROR: std::cerr << " [C_ERROR]"; break;
case Expression::Concrete_Type::NUM_TYPES: std::cerr << " [NUM_TYPES]"; break;
}
std::cerr << std::endl;
} else if (dynamic_cast<Has_Block*>(node)) {
Has_Block* has_block = dynamic_cast<Has_Block*>(node);
std::cerr << ind << "Has_Block " << has_block;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << has_block->tabs() << std::endl;
if (has_block->block()) for(auto i : has_block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Statement*>(node)) {
Statement* statement = dynamic_cast<Statement*>(node);
std::cerr << ind << "Statement " << statement;
std::cerr << " (" << pstate_source_position(node) << ")";
std::cerr << " " << statement->tabs() << std::endl;
}
if (ind == "") std::cerr << "####################################################################\n";
}
static void* reader_thread(void * /*arg*/)
{
uint8_t tmp[16]; /* actually 6 should be enough */
int count;
int len;
uint16_t packlen;
uint8_t* buf;
dmx = new cDemux();
#if defined (PLATFORM_COOLSTREAM)
dmx->Open(DMX_PES_CHANNEL);
#else
dmx->Open(DMX_PES_CHANNEL, 64*1024, live_fe);
#endif
while (reader_running)
{
//dmx->Open(DMX_PES_CHANNEL, 64*1024, live_fe?live_fe->fenumber:0);
if(dvbsub_stopped /*dvbsub_paused*/)
{
sub_debug.print(Debug::VERBOSE, "%s stopped\n", __FUNCTION__);
dmx->Stop();
pthread_mutex_lock(&packetMutex);
pthread_cond_broadcast(&packetCond);
pthread_mutex_unlock(&packetMutex);
pthread_mutex_lock(&readerMutex );
int ret = pthread_cond_wait(&readerCond, &readerMutex);
pthread_mutex_unlock(&readerMutex);
if (ret)
{
sub_debug.print(Debug::VERBOSE, "pthread_cond_timedwait fails with %d\n", ret);
}
if(!reader_running)
break;
dvbsub_stopped = 0;
sub_debug.print(Debug::VERBOSE, "%s (re)started with pid 0x%x\n", __FUNCTION__, dvbsub_pid);
}
if(pid_change_req)
{
pid_change_req = 0;
clear_queue();
dmx->Stop();
//
#if defined (PLATFORM_COOLSTREAM)
dmx->Open(DMX_PES_CHANNEL);
#else
dmx->Open(DMX_PES_CHANNEL, 64*1024, live_fe/*?live_fe->fenumber:0*/);
#endif
//
dmx->pesFilter(dvbsub_pid);
dmx->Start();
sub_debug.print(Debug::VERBOSE, "%s changed to pid 0x%x\n", __FUNCTION__, dvbsub_pid);
}
len = 0;
count = 0;
len = dmx->Read(tmp, 6, 1000);
//printf("\n[dvbsub] len: %d\n", len);
if(len <= 0)
continue;
if(memcmp(tmp, "\x00\x00\x01\xbd", 4))
{
sub_debug.print(Debug::VERBOSE, "[subtitles] bad start code: %02x%02x%02x%02x\n", tmp[0], tmp[1], tmp[2], tmp[3]);
continue;
}
count = 6;
packlen = getbits(tmp, 4*8, 16) + 6;
buf = (uint8_t*) malloc(packlen);
memcpy(buf, tmp, 6);
/* read rest of the packet */
while((count < packlen) /* && !dvbsub_paused*/)
{
len = dmx->Read(buf+count, packlen-count, 1000);
if (len < 0) {
continue;
} else {
count += len;
}
}
#if 0
for(int i = 6; i < packlen - 4; i++) {
if(!memcmp(&buf[i], "\x00\x00\x01\xbd", 4)) {
int plen = getbits(&buf[i], 4*8, 16) + 6;
printf("[subtitles] PES header at %d ?!\n", i);
printf("[subtitles] start code: %02x%02x%02x%02x len %d\n", buf[i+0], buf[i+1], buf[i+2], buf[i+3], plen);
free(buf);
continue;
}
}
#endif
if(!dvbsub_stopped /*!dvbsub_paused*/ )
{
//sub_debug.print(Debug::VERBOSE, "[subtitles] new packet, len %d buf 0x%x pts-stc diff %lld\n", count, buf, get_pts_stc_delta(get_pts(buf)));
/* Packet now in memory */
packet_queue.push(buf);
/* TODO: allocation exception */
// wake up dvb thread
pthread_mutex_lock(&packetMutex);
pthread_cond_broadcast(&packetCond);
pthread_mutex_unlock(&packetMutex);
}
else
{
free(buf);
buf=NULL;
}
}
dmx->Stop();
delete dmx;
dmx = NULL;
sub_debug.print(Debug::VERBOSE, "%s shutdown\n", __FUNCTION__);
pthread_exit(NULL);
}
int main (int argc, char** argv)
{
//---------------------------------------------------------------------------------------------------
//-- Initialization stuff
//---------------------------------------------------------------------------------------------------
//-- Command-line arguments
float ransac_threshold = 0.02;
float hsv_s_threshold = 0.30;
float hsv_v_threshold = 0.35;
//-- Show usage
if (pcl::console::find_switch(argc, argv, "-h") || pcl::console::find_switch(argc, argv, "--help"))
{
show_usage(argv[0]);
return 0;
}
if (pcl::console::find_switch(argc, argv, "--ransac-threshold"))
pcl::console::parse_argument(argc, argv, "--ransac-threshold", ransac_threshold);
else
{
std::cerr << "RANSAC theshold not specified, using default value..." << std::endl;
}
if (pcl::console::find_switch(argc, argv, "--hsv-s-threshold"))
pcl::console::parse_argument(argc, argv, "--hsv-s-threshold", hsv_s_threshold);
else
{
std::cerr << "Saturation theshold not specified, using default value..." << std::endl;
}
if (pcl::console::find_switch(argc, argv, "--hsv-v-threshold"))
pcl::console::parse_argument(argc, argv, "--hsv-v-threshold", hsv_v_threshold);
else
{
std::cerr << "Value theshold not specified, using default value..." << std::endl;
}
//-- Get point cloud file from arguments
std::vector<int> filenames;
bool file_is_pcd = false;
filenames = pcl::console::parse_file_extension_argument(argc, argv, ".ply");
if (filenames.size() != 1)
{
filenames = pcl::console::parse_file_extension_argument(argc, argv, ".pcd");
if (filenames.size() != 1)
{
show_usage(argv[0]);
return -1;
}
file_is_pcd = true;
}
//-- Load point cloud data
pcl::PointCloud<pcl::PointXYZ>::Ptr source_cloud(new pcl::PointCloud<pcl::PointXYZ>);
if (file_is_pcd)
{
if (pcl::io::loadPCDFile(argv[filenames[0]], *source_cloud) < 0)
{
std::cout << "Error loading point cloud " << argv[filenames[0]] << std::endl << std::endl;
show_usage(argv[0]);
return -1;
}
}
else
{
if (pcl::io::loadPLYFile(argv[filenames[0]], *source_cloud) < 0)
{
std::cout << "Error loading point cloud " << argv[filenames[0]] << std::endl << std::endl;
show_usage(argv[0]);
return -1;
}
}
//-- Load point cloud data (with color)
pcl::PointCloud<pcl::PointXYZRGB>::Ptr source_cloud_color(new pcl::PointCloud<pcl::PointXYZRGB>);
if (file_is_pcd)
{
if (pcl::io::loadPCDFile(argv[filenames[0]], *source_cloud_color) < 0)
{
std::cout << "Error loading colored point cloud " << argv[filenames[0]] << std::endl << std::endl;
show_usage(argv[0]);
return -1;
}
}
else
{
if (pcl::io::loadPLYFile(argv[filenames[0]], *source_cloud_color) < 0)
{
std::cout << "Error loading colored point cloud " << argv[filenames[0]] << std::endl << std::endl;
show_usage(argv[0]);
return -1;
}
}
//-- Print arguments to user
std::cout << "Selected arguments: " << std::endl
<< "\tRANSAC threshold: " << ransac_threshold << std::endl
<< "\tColor point threshold: " << hsv_s_threshold << std::endl
<< "\tColor region threshold: " << hsv_v_threshold << std::endl;
pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_filtered(new pcl::PointCloud<pcl::PointXYZ>);
//--------------------------------------------------------------------------------------------------------
//-- Program does actual work from here
//--------------------------------------------------------------------------------------------------------
Debug debug;
debug.setAutoShow(false);
debug.setEnabled(false);
debug.setEnabled(true);
debug.plotPointCloud<pcl::PointXYZRGB>(source_cloud_color, Debug::COLOR_ORIGINAL);
debug.show("Original with color");
//-- Downsample the dataset prior to plane detection (using a leaf size of 1cm)
//-----------------------------------------------------------------------------------
pcl::VoxelGrid<pcl::PointXYZ> voxel_grid;
voxel_grid.setInputCloud(source_cloud);
voxel_grid.setLeafSize(0.01f, 0.01f, 0.01f);
voxel_grid.filter(*cloud_filtered);
std::cout << "Initially PointCloud has: " << source_cloud->points.size () << " data points." << std::endl;
std::cout << "PointCloud after filtering has: " << cloud_filtered->points.size () << " data points." << std::endl;
//-- Detect all possible planes
//-----------------------------------------------------------------------------------
std::vector<pcl::ModelCoefficientsPtr> all_planes;
pcl::SACSegmentation<pcl::PointXYZ> ransac_segmentation;
ransac_segmentation.setOptimizeCoefficients(true);
ransac_segmentation.setModelType(pcl::SACMODEL_PLANE);
ransac_segmentation.setMethodType(pcl::SAC_RANSAC);
ransac_segmentation.setDistanceThreshold(ransac_threshold);
pcl::PointIndices::Ptr inliers(new pcl::PointIndices);
pcl::ModelCoefficients::Ptr current_plane(new pcl::ModelCoefficients);
int i=0, nr_points = (int) cloud_filtered->points.size();
while (cloud_filtered->points.size() > 0.3 * nr_points)
{
// Segment the largest planar component from the remaining cloud
ransac_segmentation.setInputCloud(cloud_filtered);
ransac_segmentation.segment(*inliers, *current_plane);
if (inliers->indices.size() == 0)
{
std::cout << "Could not estimate a planar model for the given dataset." << std::endl;
break;
}
// Extract the planar inliers from the input cloud
pcl::PointCloud<pcl::PointXYZ>::Ptr cloud_f(new pcl::PointCloud<pcl::PointXYZ>);
pcl::ExtractIndices<pcl::PointXYZ> extract;
extract.setInputCloud(cloud_filtered);
extract.setIndices(inliers);
extract.setNegative(false);
// Remove the planar inliers, extract the rest
extract.setNegative(true);
extract.filter(*cloud_f);
*cloud_filtered = *cloud_f;
//-- Save plane
pcl::ModelCoefficients::Ptr copy_current_plane(new pcl::ModelCoefficients);
*copy_current_plane = *current_plane;
all_planes.push_back(copy_current_plane);
//-- Debug stuff
debug.setEnabled(false);
debug.plotPlane(*current_plane, Debug::COLOR_BLUE);
debug.plotPointCloud<pcl::PointXYZ>(cloud_filtered, Debug::COLOR_RED);
debug.show("Plane segmentation");
}
//-- Filter planes to obtain garment plane
//-----------------------------------------------------------------------------------
pcl::ModelCoefficients::Ptr garment_plane(new pcl::ModelCoefficients);
float min_height = FLT_MAX;
pcl::PointXYZ garment_projected_center;
for(int i = 0; i < all_planes.size(); i++)
{
//-- Check orientation
Eigen::Vector3f normal_vector(all_planes[i]->values[0],
all_planes[i]->values[1],
all_planes[i]->values[2]);
normal_vector.normalize();
Eigen::Vector3f good_orientation(0, -1, -1);
good_orientation.normalize();
std::cout << "Checking vector with dot product: " << std::abs(normal_vector.dot(good_orientation)) << std::endl;
if (std::abs(normal_vector.dot(good_orientation)) >= 0.9)
{
//-- Check "height" (height is defined in the local frame of reference in the yz direction)
//-- With this frame, it is approximately equal to the norm of the vector OO' (being O the
//-- center of the old frame and O' the projection of that center onto the plane).
//-- Project center point onto given plane:
pcl::PointCloud<pcl::PointXYZ>::Ptr center_to_be_projected_cloud(new pcl::PointCloud<pcl::PointXYZ>);
center_to_be_projected_cloud->points.push_back(pcl::PointXYZ(0,0,0));
pcl::PointCloud<pcl::PointXYZ>::Ptr center_projected_cloud(new pcl::PointCloud<pcl::PointXYZ>);
pcl::ProjectInliers<pcl::PointXYZ> project_inliners;
project_inliners.setModelType(pcl::SACMODEL_PLANE);
project_inliners.setInputCloud(center_to_be_projected_cloud);
project_inliners.setModelCoefficients(all_planes[i]);
project_inliners.filter(*center_projected_cloud);
pcl::PointXYZ projected_center = center_projected_cloud->points[0];
Eigen::Vector3f projected_center_vector(projected_center.x, projected_center.y, projected_center.z);
float height = projected_center_vector.norm();
if (height < min_height)
{
min_height = height;
*garment_plane = *all_planes[i];
garment_projected_center = projected_center;
}
}
}
if (!(min_height < FLT_MAX))
{
std::cerr << "Garment plane not found!" << std::endl;
return -3;
}
else
{
std::cout << "Found closest plane with h=" << min_height << std::endl;
//-- Debug stuff
debug.setEnabled(true);
debug.plotPlane(*garment_plane, Debug::COLOR_BLUE);
debug.plotPointCloud<pcl::PointXYZ>(source_cloud, Debug::COLOR_RED);
debug.show("Garment plane");
}
//-- Reorient cloud to origin (with color point cloud)
//-----------------------------------------------------------------------------------
//-- Translating to center
//pcl::PointCloud<pcl::PointXYZRGB>::Ptr centered_cloud(new pcl::PointCloud<pcl::PointXYZRGB>);
Eigen::Affine3f translation_transform = Eigen::Affine3f::Identity();
translation_transform.translation() << -garment_projected_center.x, -garment_projected_center.y, -garment_projected_center.z;
//pcl::transformPointCloud(*source_cloud_color, *centered_cloud, translation_transform);
//-- Orient using the plane normal
pcl::PointCloud<pcl::PointXYZRGB>::Ptr oriented_cloud(new pcl::PointCloud<pcl::PointXYZRGB>);
Eigen::Vector3f normal_vector(garment_plane->values[0], garment_plane->values[1], garment_plane->values[2]);
//-- Check normal vector orientation
if (normal_vector.dot(Eigen::Vector3f::UnitZ()) >= 0 && normal_vector.dot(Eigen::Vector3f::UnitY()) >= 0)
normal_vector = -normal_vector;
Eigen::Quaternionf rotation_quaternion = Eigen::Quaternionf().setFromTwoVectors(normal_vector, Eigen::Vector3f::UnitZ());
//pcl::transformPointCloud(*centered_cloud, *oriented_cloud, Eigen::Vector3f(0,0,0), rotation_quaternion);
Eigen::Transform<float, 3, Eigen::Affine> t(rotation_quaternion * translation_transform);
pcl::transformPointCloud(*source_cloud_color, *oriented_cloud, t);
//-- Save to file
record_transformation(argv[filenames[0]]+std::string("-transform1.txt"), translation_transform, rotation_quaternion);
debug.setEnabled(true);
debug.plotPointCloud<pcl::PointXYZRGB>(oriented_cloud, Debug::COLOR_GREEN);
debug.show("Oriented");
//-- Filter points under the garment table
//-----------------------------------------------------------------------------------
pcl::PointCloud<pcl::PointXYZRGB>::Ptr garment_table_cloud(new pcl::PointCloud<pcl::PointXYZRGB>);
pcl::PassThrough<pcl::PointXYZRGB> passthrough_filter;
passthrough_filter.setInputCloud(oriented_cloud);
passthrough_filter.setFilterFieldName("z");
passthrough_filter.setFilterLimits(-ransac_threshold/2.0f, FLT_MAX);
passthrough_filter.setFilterLimitsNegative(false);
passthrough_filter.filter(*garment_table_cloud);
debug.setEnabled(true);
debug.plotPointCloud<pcl::PointXYZRGB>(garment_table_cloud, Debug::COLOR_GREEN);
debug.show("Table cloud (filtered)");
//-- Color segmentation of the garment
//-----------------------------------------------------------------------------------
//-- HSV thresholding
pcl::PointCloud<pcl::PointXYZHSV>::Ptr hsv_cloud(new pcl::PointCloud<pcl::PointXYZHSV>);
pcl::PointCloud<pcl::PointXYZRGB>::Ptr filtered_garment_cloud(new pcl::PointCloud<pcl::PointXYZRGB>);
pcl::PointCloudXYZRGBtoXYZHSV(*garment_table_cloud, *hsv_cloud);
for (int i = 0; i < hsv_cloud->points.size(); i++)
{
if (isnan(hsv_cloud->points[i].x) || isnan(hsv_cloud->points[i].y || isnan(hsv_cloud->points[i].z)))
continue;
if (hsv_cloud->points[i].s > hsv_s_threshold && hsv_cloud->points[i].v > hsv_v_threshold)
filtered_garment_cloud->push_back(garment_table_cloud->points[i]);
}
debug.setEnabled(true);
debug.plotPointCloud<pcl::PointXYZRGB>(filtered_garment_cloud, Debug::COLOR_GREEN);
debug.show("Garment cloud");
//-- Euclidean Clustering of the resultant cloud
pcl::search::KdTree<pcl::PointXYZRGB>::Ptr tree(new pcl::search::KdTree<pcl::PointXYZRGB>);
tree->setInputCloud(filtered_garment_cloud);
std::vector<pcl::PointIndices> cluster_indices;
pcl::EuclideanClusterExtraction<pcl::PointXYZRGB> euclidean_custering;
euclidean_custering.setClusterTolerance(0.005);
euclidean_custering.setMinClusterSize(100);
euclidean_custering.setSearchMethod(tree);
euclidean_custering.setInputCloud(filtered_garment_cloud);
euclidean_custering.extract(cluster_indices);
pcl::PointCloud<pcl::PointXYZRGB>::Ptr largest_color_cluster(new pcl::PointCloud<pcl::PointXYZRGB>);
int largest_cluster_size = 0;
for (auto it = cluster_indices.begin (); it != cluster_indices.end (); ++it)
{
pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud_cluster (new pcl::PointCloud<pcl::PointXYZRGB>);
for (auto pit = it->indices.begin (); pit != it->indices.end (); ++pit)
cloud_cluster->points.push_back(filtered_garment_cloud->points[*pit]);
cloud_cluster->width = cloud_cluster->points.size ();
cloud_cluster->height = 1;
cloud_cluster->is_dense = true;
std::cout << "Found cluster of " << cloud_cluster->points.size() << " points." << std::endl;
if (cloud_cluster->points.size() > largest_cluster_size)
{
largest_cluster_size = cloud_cluster->points.size();
*largest_color_cluster = *cloud_cluster;
}
}
debug.setEnabled(true);
debug.plotPointCloud<pcl::PointXYZRGB>(largest_color_cluster, Debug::COLOR_GREEN);
debug.show("Filtered garment cloud");
//-- Centering the point cloud before saving it
//-----------------------------------------------------------------------------------
//-- Find bounding box
pcl::MomentOfInertiaEstimation<pcl::PointXYZRGB> feature_extractor;
pcl::PointXYZRGB min_point_AABB, max_point_AABB;
pcl::PointXYZRGB min_point_OBB, max_point_OBB;
pcl::PointXYZRGB position_OBB;
Eigen::Matrix3f rotational_matrix_OBB;
feature_extractor.setInputCloud(largest_color_cluster);
feature_extractor.compute();
feature_extractor.getAABB(min_point_AABB, max_point_AABB);
feature_extractor.getOBB(min_point_OBB, max_point_OBB, position_OBB, rotational_matrix_OBB);
//-- Translating to center
pcl::PointCloud<pcl::PointXYZRGB>::Ptr centered_garment_cloud(new pcl::PointCloud<pcl::PointXYZRGB>);
Eigen::Affine3f garment_translation_transform = Eigen::Affine3f::Identity();
garment_translation_transform.translation() << -position_OBB.x, -position_OBB.y, -position_OBB.z;
pcl::transformPointCloud(*largest_color_cluster, *centered_garment_cloud, garment_translation_transform);
//-- Orient using the principal axes of the bounding box
pcl::PointCloud<pcl::PointXYZRGB>::Ptr oriented_garment_cloud(new pcl::PointCloud<pcl::PointXYZRGB>);
Eigen::Vector3f principal_axis_x(max_point_OBB.x - min_point_OBB.x, 0, 0);
Eigen::Quaternionf garment_rotation_quaternion = Eigen::Quaternionf().setFromTwoVectors(principal_axis_x, Eigen::Vector3f::UnitX()); //-- This transformation is wrong (I guess)
Eigen::Transform<float, 3, Eigen::Affine> t2 = Eigen::Transform<float, 3, Eigen::Affine>::Identity();
t2.rotate(rotational_matrix_OBB.inverse());
//pcl::transformPointCloud(*centered_garment_cloud, *oriented_garment_cloud, Eigen::Vector3f(0,0,0), garment_rotation_quaternion);
pcl::transformPointCloud(*centered_garment_cloud, *oriented_garment_cloud, t2);
//-- Save to file
record_transformation(argv[filenames[0]]+std::string("-transform2.txt"), garment_translation_transform, Eigen::Quaternionf(t2.rotation()));
debug.setEnabled(true);
debug.plotPointCloud<pcl::PointXYZRGB>(oriented_garment_cloud, Debug::COLOR_GREEN);
debug.plotBoundingBox(min_point_OBB, max_point_OBB, position_OBB, rotational_matrix_OBB, Debug::COLOR_YELLOW);
debug.show("Oriented garment patch");
//-- Save point cloud in file to process it in Python
pcl::io::savePCDFileBinary(argv[filenames[0]]+std::string("-output.pcd"), *oriented_garment_cloud);
return 0;
}
inline void debug_ast(AST_Node* node, string ind = "", Env* env = 0)
{
if (node == 0) return;
if (ind == "") cerr << "####################################################################\n";
if (dynamic_cast<Bubble*>(node)) {
Bubble* bubble = dynamic_cast<Bubble*>(node);
cerr << ind << "Bubble " << bubble << " " << bubble->tabs() << endl;
} else if (dynamic_cast<At_Root_Block*>(node)) {
At_Root_Block* root_block = dynamic_cast<At_Root_Block*>(node);
cerr << ind << "At_Root_Block " << root_block << " " << root_block->tabs() << endl;
if (root_block->block()) for(auto i : root_block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Selector_List*>(node)) {
Selector_List* selector = dynamic_cast<Selector_List*>(node);
cerr << ind << "Selector_List " << selector
<< " [block:" << selector->last_block() << "]"
<< (selector->last_block() && selector->last_block()->is_root() ? " [root]" : "")
<< " [@media:" << selector->media_block() << "]"
<< (selector->is_optional() ? " [is_optional]": " -")
<< (selector->has_line_break() ? " [line-break]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< endl;
for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
// } else if (dynamic_cast<Expression*>(node)) {
// Expression* expression = dynamic_cast<Expression*>(node);
// cerr << ind << "Expression " << expression << " " << expression->concrete_type() << endl;
} else if (dynamic_cast<Parent_Selector*>(node)) {
Parent_Selector* selector = dynamic_cast<Parent_Selector*>(node);
cerr << ind << "Parent_Selector " << selector;
cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << endl;
debug_ast(selector->selector(), ind + "->", env);
} else if (dynamic_cast<Complex_Selector*>(node)) {
Complex_Selector* selector = dynamic_cast<Complex_Selector*>(node);
cerr << ind << "Complex_Selector " << selector
<< " [block:" << selector->last_block() << "]"
<< " [weight:" << longToHex(selector->specificity()) << "]"
<< (selector->last_block() && selector->last_block()->is_root() ? " [root]" : "")
<< " [@media:" << selector->media_block() << "]"
<< (selector->is_optional() ? " [is_optional]": " -")
<< (selector->has_line_break() ? " [line-break]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -") << " -> ";
switch (selector->combinator()) {
case Complex_Selector::PARENT_OF: cerr << "{>}"; break;
case Complex_Selector::PRECEDES: cerr << "{~}"; break;
case Complex_Selector::ADJACENT_TO: cerr << "{+}"; break;
case Complex_Selector::ANCESTOR_OF: cerr << "{ }"; break;
}
cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << endl;
debug_ast(selector->head(), ind + " ", env);
debug_ast(selector->tail(), ind + "-", env);
} else if (dynamic_cast<Compound_Selector*>(node)) {
Compound_Selector* selector = dynamic_cast<Compound_Selector*>(node);
cerr << ind << "Compound_Selector " << selector;
cerr << " [block:" << selector->last_block() << "]";
cerr << " [weight:" << longToHex(selector->specificity()) << "]";
// cerr << (selector->last_block() && selector->last_block()->is_root() ? " [root]" : "");
cerr << " [@media:" << selector->media_block() << "]";
cerr << (selector->is_optional() ? " [is_optional]": " -");
cerr << (selector->has_line_break() ? " [line-break]": " -");
cerr << (selector->has_line_feed() ? " [line-feed]": " -");
cerr << " <" << prettyprint(selector->pstate().token.ws_before()) << ">" << endl;
for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Propset*>(node)) {
Propset* selector = dynamic_cast<Propset*>(node);
cerr << ind << "Propset " << selector << " " << selector->tabs() << endl;
if (selector->block()) for(auto i : selector->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Wrapped_Selector*>(node)) {
Wrapped_Selector* selector = dynamic_cast<Wrapped_Selector*>(node);
cerr << ind << "Wrapped_Selector " << selector << " <<" << selector->name() << ">>" << (selector->has_line_break() ? " [line-break]": " -") << (selector->has_line_feed() ? " [line-feed]": " -") << endl;
debug_ast(selector->selector(), ind + " () ", env);
} else if (dynamic_cast<Pseudo_Selector*>(node)) {
Pseudo_Selector* selector = dynamic_cast<Pseudo_Selector*>(node);
cerr << ind << "Pseudo_Selector " << selector << " <<" << selector->name() << ">>" << (selector->has_line_break() ? " [line-break]": " -") << (selector->has_line_feed() ? " [line-feed]": " -") << endl;
debug_ast(selector->expression(), ind + " <= ", env);
} else if (dynamic_cast<Attribute_Selector*>(node)) {
Attribute_Selector* selector = dynamic_cast<Attribute_Selector*>(node);
cerr << ind << "Attribute_Selector " << selector << " <<" << selector->name() << ">>" << (selector->has_line_break() ? " [line-break]": " -") << (selector->has_line_feed() ? " [line-feed]": " -") << endl;
debug_ast(selector->value(), ind + "[" + selector->matcher() + "] ", env);
} else if (dynamic_cast<Selector_Qualifier*>(node)) {
Selector_Qualifier* selector = dynamic_cast<Selector_Qualifier*>(node);
cerr << ind << "Selector_Qualifier " << selector << " <<" << selector->name() << ">>" << (selector->has_line_break() ? " [line-break]": " -") << (selector->has_line_feed() ? " [line-feed]": " -") << endl;
} else if (dynamic_cast<Type_Selector*>(node)) {
Type_Selector* selector = dynamic_cast<Type_Selector*>(node);
cerr << ind << "Type_Selector " << selector << " <<" << selector->name() << ">>" << (selector->has_line_break() ? " [line-break]": " -") <<
" <" << prettyprint(selector->pstate().token.ws_before()) << ">" << endl;
} else if (dynamic_cast<Selector_Placeholder*>(node)) {
Selector_Placeholder* selector = dynamic_cast<Selector_Placeholder*>(node);
cerr << ind << "Selector_Placeholder [" << selector->name() << "] " << selector
<< " [block:" << selector->last_block() << "]"
<< " [@media:" << selector->media_block() << "]"
<< (selector->is_optional() ? " [is_optional]": " -")
<< (selector->has_line_break() ? " [line-break]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< endl;
} else if (dynamic_cast<Selector_Reference*>(node)) {
Selector_Reference* selector = dynamic_cast<Selector_Reference*>(node);
cerr << ind << "Selector_Reference " << selector << " @ref " << selector->selector() << endl;
} else if (dynamic_cast<Simple_Selector*>(node)) {
Simple_Selector* selector = dynamic_cast<Simple_Selector*>(node);
cerr << ind << "Simple_Selector " << selector << (selector->has_line_break() ? " [line-break]": " -") << (selector->has_line_feed() ? " [line-feed]": " -") << endl;
} else if (dynamic_cast<Selector_Schema*>(node)) {
Selector_Schema* selector = dynamic_cast<Selector_Schema*>(node);
cerr << ind << "Selector_Schema " << selector
<< " [block:" << selector->last_block() << "]"
<< (selector->last_block() && selector->last_block()->is_root() ? " [root]" : "")
<< " [@media:" << selector->media_block() << "]"
<< (selector->has_line_break() ? " [line-break]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< endl;
debug_ast(selector->contents(), ind + " ");
// for(auto i : selector->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Selector*>(node)) {
Selector* selector = dynamic_cast<Selector*>(node);
cerr << ind << "Selector " << selector
<< (selector->has_line_break() ? " [line-break]": " -")
<< (selector->has_line_feed() ? " [line-feed]": " -")
<< endl;
} else if (dynamic_cast<Media_Query_Expression*>(node)) {
Media_Query_Expression* block = dynamic_cast<Media_Query_Expression*>(node);
cerr << ind << "Media_Query_Expression " << block
<< (block->is_interpolated() ? " [is_interpolated]": " -")
<< endl;
debug_ast(block->feature(), ind + " f) ");
debug_ast(block->value(), ind + " v) ");
} else if (dynamic_cast<Media_Query*>(node)) {
Media_Query* block = dynamic_cast<Media_Query*>(node);
cerr << ind << "Media_Query " << block
<< (block->is_negated() ? " [is_negated]": " -")
<< (block->is_restricted() ? " [is_restricted]": " -")
<< endl;
debug_ast(block->media_type(), ind + " ");
for(auto i : block->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Media_Block*>(node)) {
Media_Block* block = dynamic_cast<Media_Block*>(node);
cerr << ind << "Media_Block " << block << " " << block->tabs() << endl;
debug_ast(block->media_queries(), ind + " =@ ");
debug_ast(block->selector(), ind + " -@ ");
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Feature_Block*>(node)) {
Feature_Block* block = dynamic_cast<Feature_Block*>(node);
cerr << ind << "Feature_Block " << block << " " << block->tabs() << endl;
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Block*>(node)) {
Block* root_block = dynamic_cast<Block*>(node);
cerr << ind << "Block " << root_block << " " << root_block->tabs() << endl;
if (root_block->block()) for(auto i : root_block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Warning*>(node)) {
Warning* block = dynamic_cast<Warning*>(node);
cerr << ind << "Warning " << block << " " << block->tabs() << endl;
} else if (dynamic_cast<Error*>(node)) {
Error* block = dynamic_cast<Error*>(node);
cerr << ind << "Error " << block << " " << block->tabs() << endl;
} else if (dynamic_cast<Debug*>(node)) {
Debug* block = dynamic_cast<Debug*>(node);
cerr << ind << "Debug " << block << " " << block->tabs() << endl;
} else if (dynamic_cast<Comment*>(node)) {
Comment* block = dynamic_cast<Comment*>(node);
cerr << ind << "Comment " << block << " " << block->tabs() <<
" <" << prettyprint(block->pstate().token.ws_before()) << ">" << endl;
debug_ast(block->text(), ind + "// ", env);
} else if (dynamic_cast<If*>(node)) {
If* block = dynamic_cast<If*>(node);
cerr << ind << "If " << block << " " << block->tabs() << endl;
} else if (dynamic_cast<Return*>(node)) {
Return* block = dynamic_cast<Return*>(node);
cerr << ind << "Return " << block << " " << block->tabs() << endl;
} else if (dynamic_cast<Extension*>(node)) {
Extension* block = dynamic_cast<Extension*>(node);
cerr << ind << "Extension " << block << " " << block->tabs() << endl;
debug_ast(block->selector(), ind + "-> ", env);
} else if (dynamic_cast<Content*>(node)) {
Content* block = dynamic_cast<Content*>(node);
cerr << ind << "Content " << block << " " << block->tabs() << endl;
} else if (dynamic_cast<Import_Stub*>(node)) {
Import_Stub* block = dynamic_cast<Import_Stub*>(node);
cerr << ind << "Import_Stub " << block << " " << block->tabs() << endl;
} else if (dynamic_cast<Import*>(node)) {
Import* block = dynamic_cast<Import*>(node);
cerr << ind << "Import " << block << " " << block->tabs() << endl;
// vector<string> files_;
for (auto imp : block->urls()) debug_ast(imp, "@ ", env);
} else if (dynamic_cast<Assignment*>(node)) {
Assignment* block = dynamic_cast<Assignment*>(node);
cerr << ind << "Assignment " << block << " <<" << block->variable() << ">> " << block->tabs() << endl;
debug_ast(block->value(), ind + "=", env);
} else if (dynamic_cast<Declaration*>(node)) {
Declaration* block = dynamic_cast<Declaration*>(node);
cerr << ind << "Declaration " << block << " " << block->tabs() << endl;
debug_ast(block->property(), ind + " prop: ", env);
debug_ast(block->value(), ind + " value: ", env);
} else if (dynamic_cast<Keyframe_Rule*>(node)) {
Keyframe_Rule* has_block = dynamic_cast<Keyframe_Rule*>(node);
cerr << ind << "Keyframe_Rule " << has_block << " " << has_block->tabs() << endl;
if (has_block->selector()) debug_ast(has_block->selector(), ind + "@");
if (has_block->block()) for(auto i : has_block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<At_Rule*>(node)) {
At_Rule* block = dynamic_cast<At_Rule*>(node);
cerr << ind << "At_Rule " << block << " [" << block->keyword() << "] " << block->tabs() << endl;
debug_ast(block->value(), ind + "+", env);
debug_ast(block->selector(), ind + "~", env);
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Each*>(node)) {
Each* block = dynamic_cast<Each*>(node);
cerr << ind << "Each " << block << " " << block->tabs() << endl;
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<For*>(node)) {
For* block = dynamic_cast<For*>(node);
cerr << ind << "For " << block << " " << block->tabs() << endl;
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<While*>(node)) {
While* block = dynamic_cast<While*>(node);
cerr << ind << "While " << block << " " << block->tabs() << endl;
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Definition*>(node)) {
Definition* block = dynamic_cast<Definition*>(node);
cerr << ind << "Definition " << block << " " << block->tabs() << endl;
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Mixin_Call*>(node)) {
Mixin_Call* block = dynamic_cast<Mixin_Call*>(node);
cerr << ind << "Mixin_Call " << block << " " << block->tabs() << endl;
if (block->block()) for(auto i : block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Ruleset*>(node)) {
Ruleset* ruleset = dynamic_cast<Ruleset*>(node);
cerr << ind << "Ruleset " << ruleset << " " << ruleset->tabs() << endl;
debug_ast(ruleset->selector(), ind + " ");
if (ruleset->block()) for(auto i : ruleset->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Block*>(node)) {
Block* block = dynamic_cast<Block*>(node);
cerr << ind << "Block " << block << " " << block->tabs() << endl;
for(auto i : block->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Textual*>(node)) {
Textual* expression = dynamic_cast<Textual*>(node);
cerr << ind << "Textual ";
if (expression->type() == Textual::NUMBER) cerr << " [NUMBER]";
else if (expression->type() == Textual::PERCENTAGE) cerr << " [PERCENTAGE]";
else if (expression->type() == Textual::DIMENSION) cerr << " [DIMENSION]";
else if (expression->type() == Textual::HEX) cerr << " [HEX]";
cerr << expression << " [" << expression->value() << "]" << endl;
} else if (dynamic_cast<Variable*>(node)) {
Variable* expression = dynamic_cast<Variable*>(node);
cerr << ind << "Variable " << expression << " [" << expression->name() << "]" << endl;
string name(expression->name());
if (env && env->has(name)) debug_ast(static_cast<Expression*>((*env)[name]), ind + " -> ", env);
} else if (dynamic_cast<Function_Call_Schema*>(node)) {
Function_Call_Schema* expression = dynamic_cast<Function_Call_Schema*>(node);
cerr << ind << "Function_Call_Schema " << expression << "]" << endl;
debug_ast(expression->name(), ind + "name: ", env);
debug_ast(expression->arguments(), ind + " args: ", env);
} else if (dynamic_cast<Function_Call*>(node)) {
Function_Call* expression = dynamic_cast<Function_Call*>(node);
cerr << ind << "Function_Call " << expression << " [" << expression->name() << "]" << endl;
debug_ast(expression->arguments(), ind + " args: ", env);
} else if (dynamic_cast<Arguments*>(node)) {
Arguments* expression = dynamic_cast<Arguments*>(node);
cerr << ind << "Arguments " << expression << "]" << endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Argument*>(node)) {
Argument* expression = dynamic_cast<Argument*>(node);
cerr << ind << "Argument " << expression << " [" << expression->value() << "]" << endl;
debug_ast(expression->value(), ind + " value: ", env);
} else if (dynamic_cast<Unary_Expression*>(node)) {
Unary_Expression* expression = dynamic_cast<Unary_Expression*>(node);
cerr << ind << "Unary_Expression " << expression << " [" << expression->type() << "]" << endl;
debug_ast(expression->operand(), ind + " operand: ", env);
} else if (dynamic_cast<Binary_Expression*>(node)) {
Binary_Expression* expression = dynamic_cast<Binary_Expression*>(node);
cerr << ind << "Binary_Expression " << expression << " [" << expression->type() << "]" << endl;
debug_ast(expression->left(), ind + " left: ", env);
debug_ast(expression->right(), ind + " right: ", env);
} else if (dynamic_cast<Map*>(node)) {
Map* expression = dynamic_cast<Map*>(node);
cerr << ind << "Map " << expression << " [Hashed]" << endl;
} else if (dynamic_cast<List*>(node)) {
List* expression = dynamic_cast<List*>(node);
cerr << ind << "List " << expression << " (" << expression->length() << ") " <<
(expression->separator() == Sass::List::Separator::COMMA ? "Comma " : "Space ") <<
" [delayed: " << expression->is_delayed() << "] " <<
" [interpolant: " << expression->is_interpolant() << "] " <<
endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Content*>(node)) {
Content* expression = dynamic_cast<Content*>(node);
cerr << ind << "Content " << expression << " [Statement]" << endl;
} else if (dynamic_cast<Boolean*>(node)) {
Boolean* expression = dynamic_cast<Boolean*>(node);
cerr << ind << "Boolean " << expression << " [" << expression->value() << "]" << endl;
} else if (dynamic_cast<Color*>(node)) {
Color* expression = dynamic_cast<Color*>(node);
cerr << ind << "Color " << expression << " [" << expression->r() << ":" << expression->g() << ":" << expression->b() << "@" << expression->a() << "]" << endl;
} else if (dynamic_cast<Number*>(node)) {
Number* expression = dynamic_cast<Number*>(node);
cerr << ind << "Number " << expression << " [" << expression->value() << expression->unit() << "]" << endl;
} else if (dynamic_cast<String_Quoted*>(node)) {
String_Quoted* expression = dynamic_cast<String_Quoted*>(node);
cerr << ind << "String_Quoted : " << expression << " [" << prettyprint(expression->value()) << "]" <<
(expression->is_delayed() ? " {delayed}" : "") <<
(expression->sass_fix_1291() ? " {sass_fix_1291}" : "") <<
(expression->quote_mark() != 0 ? " {qm:" + string(1, expression->quote_mark()) + "}" : "") <<
" <" << prettyprint(expression->pstate().token.ws_before()) << ">" << endl;
} else if (dynamic_cast<String_Constant*>(node)) {
String_Constant* expression = dynamic_cast<String_Constant*>(node);
cerr << ind << "String_Constant : " << expression << " [" << prettyprint(expression->value()) << "]" <<
(expression->is_delayed() ? " {delayed}" : "") <<
(expression->sass_fix_1291() ? " {sass_fix_1291}" : "") <<
" <" << prettyprint(expression->pstate().token.ws_before()) << ">" << endl;
} else if (dynamic_cast<String_Schema*>(node)) {
String_Schema* expression = dynamic_cast<String_Schema*>(node);
cerr << ind << "String_Schema " << expression << " " << expression->concrete_type() <<
(expression->has_interpolants() ? " {has_interpolants}" : "") <<
endl;
for(auto i : expression->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<String*>(node)) {
String* expression = dynamic_cast<String*>(node);
cerr << ind << "String " << expression << expression->concrete_type() <<
" " << (expression->sass_fix_1291() ? "{sass_fix_1291}" : "") <<
endl;
} else if (dynamic_cast<Expression*>(node)) {
Expression* expression = dynamic_cast<Expression*>(node);
cerr << ind << "Expression " << expression;
switch (expression->concrete_type()) {
case Expression::Concrete_Type::NONE: cerr << " [NONE]"; break;
case Expression::Concrete_Type::BOOLEAN: cerr << " [BOOLEAN]"; break;
case Expression::Concrete_Type::NUMBER: cerr << " [NUMBER]"; break;
case Expression::Concrete_Type::COLOR: cerr << " [COLOR]"; break;
case Expression::Concrete_Type::STRING: cerr << " [STRING]"; break;
case Expression::Concrete_Type::LIST: cerr << " [LIST]"; break;
case Expression::Concrete_Type::MAP: cerr << " [MAP]"; break;
case Expression::Concrete_Type::SELECTOR: cerr << " [SELECTOR]"; break;
case Expression::Concrete_Type::NULL_VAL: cerr << " [NULL_VAL]"; break;
case Expression::Concrete_Type::NUM_TYPES: cerr << " [NUM_TYPES]"; break;
}
cerr << endl;
} else if (dynamic_cast<Has_Block*>(node)) {
Has_Block* has_block = dynamic_cast<Has_Block*>(node);
cerr << ind << "Has_Block " << has_block << " " << has_block->tabs() << endl;
if (has_block->block()) for(auto i : has_block->block()->elements()) { debug_ast(i, ind + " ", env); }
} else if (dynamic_cast<Statement*>(node)) {
Statement* statement = dynamic_cast<Statement*>(node);
cerr << ind << "Statement " << statement << " " << statement->tabs() << endl;
}
if (ind == "") cerr << "####################################################################\n";
}
void AppMenuBar::OnDebug(wxCommandEvent& WXUNUSED(event)) {
Debug *debug = new Debug(wxT("debug"));
debug->nop();
}
static void* dvbsub_thread(void* /*arg*/)
{
struct timespec restartWait;
struct timeval now;
sub_debug.print(Debug::VERBOSE, "%s started\n", __FUNCTION__);
if (!dvbSubtitleConverter)
dvbSubtitleConverter = new cDvbSubtitleConverter;
int timeout = 1000000;
while(dvbsub_running)
{
uint8_t* packet;
int64_t pts;
int dataoffset;
int packlen;
gettimeofday(&now, NULL);
int ret = 0;
now.tv_usec += (timeout == 0) ? 1000000 : timeout; // add the timeout
while (now.tv_usec >= 1000000)
{
// take care of an overflow
now.tv_sec++;
now.tv_usec -= 1000000;
}
restartWait.tv_sec = now.tv_sec; // seconds
restartWait.tv_nsec = now.tv_usec * 1000; // nano seconds
pthread_mutex_lock( &packetMutex );
ret = pthread_cond_timedwait( &packetCond, &packetMutex, &restartWait );
pthread_mutex_unlock( &packetMutex );
timeout = dvbSubtitleConverter->Action();
if(packet_queue.size() == 0) {
continue;
}
#if 1
sub_debug.print(Debug::VERBOSE, "PES: Wakeup, queue size %d\n\n", packet_queue.size());
#endif
if(dvbsub_stopped /*dvbsub_paused*/)
{
clear_queue();
continue;
}
pthread_mutex_lock(&packetMutex);
packet = packet_queue.pop();
pthread_mutex_unlock(&packetMutex);
if (!packet) {
sub_debug.print(Debug::VERBOSE, "Error no packet found\n");
continue;
}
packlen = (packet[4] << 8 | packet[5]) + 6;
pts = get_pts(packet);
dataoffset = packet[8] + 8 + 1;
if (packet[dataoffset] != 0x20)
{
#if 1
sub_debug.print(Debug::VERBOSE, "Not a dvb subtitle packet, discard it (len %d)\n", packlen);
for(int i = 0; i < packlen; i++)
printf("%02X ", packet[i]);
printf("\n");
#endif
goto next_round;
}
#if 1
sub_debug.print(Debug::VERBOSE, "PES packet: len %d data len %d PTS=%Ld (%02d:%02d:%02d.%d) diff %lld\n", packlen, packlen - (dataoffset + 2), pts, (int)(pts/324000000), (int)((pts/5400000)%60), (int)((pts/90000)%60), (int)(pts%90000), get_pts_stc_delta(pts));
#endif
if (packlen <= dataoffset + 3)
{
sub_debug.print(Debug::INFO, "Packet too short, discard\n");
goto next_round;
}
if (packet[dataoffset + 2] == 0x0f)
{
dvbSubtitleConverter->Convert(&packet[dataoffset + 2], packlen - (dataoffset + 2), pts);
}
else
{
sub_debug.print(Debug::INFO, "End_of_PES is missing\n");
}
timeout = dvbSubtitleConverter->Action();
next_round:
free(packet);
}
delete dvbSubtitleConverter;
sub_debug.print(Debug::VERBOSE, "%s shutdown\n", __FUNCTION__);
pthread_exit(NULL);
}
static void* reader_thread(void * /*arg*/)
{
int fds[2];
pipe(fds);
fcntl(fds[0], F_SETFD, FD_CLOEXEC);
fcntl(fds[0], F_SETFL, O_NONBLOCK);
fcntl(fds[1], F_SETFD, FD_CLOEXEC);
fcntl(fds[1], F_SETFL, O_NONBLOCK);
flagFd = fds[1];
uint8_t tmp[16]; /* actually 6 should be enough */
int count;
int len;
uint16_t packlen;
uint8_t* buf;
bool bad_startcode = false;
set_threadname("dvbsub:reader");
dmx = new cDemux(0);
#if HAVE_TRIPLEDRAGON
dmx->Open(DMX_PES_CHANNEL, NULL, 16*1024);
#else
dmx->Open(DMX_PES_CHANNEL, NULL, 64*1024);
#endif
while (reader_running) {
if(dvbsub_stopped /*dvbsub_paused*/) {
sub_debug.print(Debug::VERBOSE, "%s stopped\n", __FUNCTION__);
dmx->Stop();
pthread_mutex_lock(&packetMutex);
pthread_cond_broadcast(&packetCond);
pthread_mutex_unlock(&packetMutex);
pthread_mutex_lock(&readerMutex );
int ret = pthread_cond_wait(&readerCond, &readerMutex);
pthread_mutex_unlock(&readerMutex);
if (ret) {
sub_debug.print(Debug::VERBOSE, "pthread_cond_timedwait fails with %d\n", ret);
}
if(!reader_running)
break;
dvbsub_stopped = 0;
sub_debug.print(Debug::VERBOSE, "%s (re)started with pid 0x%x\n", __FUNCTION__, dvbsub_pid);
}
if(pid_change_req) {
pid_change_req = 0;
clear_queue();
dmx->Stop();
dmx->pesFilter(dvbsub_pid);
dmx->Start();
sub_debug.print(Debug::VERBOSE, "%s changed to pid 0x%x\n", __FUNCTION__, dvbsub_pid);
}
struct pollfd pfds[2];
pfds[0].fd = fds[1];
pfds[0].events = POLLIN;
char _tmp[64];
#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE
if (isEplayer) {
poll(pfds, 1, -1);
while (0 > read(pfds[0].fd, _tmp, sizeof(tmp)));
continue;
}
#endif
pfds[1].fd = dmx->getFD();
pfds[1].events = POLLIN;
switch (poll(pfds, 2, -1)) {
case 0:
case -1:
if (pfds[0].revents & POLLIN)
while (0 > read(pfds[0].fd, _tmp, sizeof(tmp)));
continue;
default:
if (pfds[0].revents & POLLIN)
while (0 > read(pfds[0].fd, _tmp, sizeof(tmp)));
if (!(pfds[1].revents & POLLIN))
continue;
}
len = dmx->Read(tmp, 6, 0);
if(len <= 0)
continue;
if(!memcmp(tmp, "\x00\x00\x01\xbe", 4)) { // padding stream
packlen = getbits(tmp, 4*8, 16) + 6;
count = 6;
buf = (uint8_t*) malloc(packlen);
// actually, we're doing slightly too much here ...
memmove(buf, tmp, 6);
/* read rest of the packet */
while((count < packlen) && !dvbsub_stopped) {
len = dmx->Read(buf+count, packlen-count, 1000);
if (len < 0) {
break;
} else {
count += len;
}
}
free(buf);
buf = NULL;
continue;
}
if(memcmp(tmp, "\x00\x00\x01\xbd", 4)) {
if (!bad_startcode) {
sub_debug.print(Debug::VERBOSE, "[subtitles] bad start code: %02x%02x%02x%02x\n", tmp[0], tmp[1], tmp[2], tmp[3]);
bad_startcode = true;
}
continue;
}
bad_startcode = false;
count = 6;
packlen = getbits(tmp, 4*8, 16) + 6;
buf = (uint8_t*) malloc(packlen);
memmove(buf, tmp, 6);
/* read rest of the packet */
while((count < packlen) && !dvbsub_stopped) {
len = dmx->Read(buf+count, packlen-count, 1000);
if (len < 0) {
break;
} else {
count += len;
}
}
#if 0
for(int i = 6; i < packlen - 4; i++) {
if(!memcmp(&buf[i], "\x00\x00\x01\xbd", 4)) {
int plen = getbits(&buf[i], 4*8, 16) + 6;
sub_debug.print(Debug::VERBOSE, "[subtitles] ******************* PES header at %d ?! *******************\n", i);
sub_debug.print(Debug::VERBOSE, "[subtitles] start code: %02x%02x%02x%02x len %d\n", buf[i+0], buf[i+1], buf[i+2], buf[i+3], plen);
free(buf);
continue;
}
}
#endif
if(!dvbsub_stopped /*!dvbsub_paused*/) {
sub_debug.print(Debug::VERBOSE, "[subtitles] *** new packet, len %d buf 0x%x pts-stc diff %lld ***\n", count, buf, get_pts_stc_delta(get_pts(buf)));
/* Packet now in memory */
pthread_mutex_lock(&packetMutex);
packet_queue.push(buf);
/* TODO: allocation exception */
// wake up dvb thread
pthread_cond_broadcast(&packetCond);
pthread_mutex_unlock(&packetMutex);
} else {
free(buf);
buf=NULL;
}
}
dmx->Stop();
delete dmx;
dmx = NULL;
close(fds[0]);
close(fds[1]);
flagFd = -1;
sub_debug.print(Debug::VERBOSE, "%s shutdown\n", __FUNCTION__);
pthread_exit(NULL);
}
static void* dvbsub_thread(void* /*arg*/)
{
struct timespec restartWait;
struct timeval now;
set_threadname("dvbsub:main");
sub_debug.print(Debug::VERBOSE, "%s started\n", __FUNCTION__);
if (!dvbSubtitleConverter)
dvbSubtitleConverter = new cDvbSubtitleConverter;
int timeout = 1000000;
#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE
CFrameBuffer *fb = CFrameBuffer::getInstance();
int xres = fb->getScreenWidth(true);
int yres = fb->getScreenHeight(true);
int clr_x0 = xres, clr_y0 = yres, clr_x1 = 0, clr_y1 = 0;
uint32_t colortable[256];
memset(colortable, 0, sizeof(colortable));
uint32_t last_color = 0;
#endif
while(dvbsub_running) {
#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE
if (ass_track) {
usleep(100000); // FIXME ... should poll instead
OpenThreads::ScopedLock<OpenThreads::Mutex> m_lock(ass_mutex);
if (!ass_track)
continue;
if (ass_size != sub_font_size) {
ass_size = sub_font_size;
ass_set_font_scale(ass_renderer, ((double) ass_size)/ASS_CUSTOM_FONT_SIZE);
}
int detect_change = 0;
int64_t pts;
getPlayerPts(&pts);
ASS_Image *image = ass_render_frame(ass_renderer, ass_track, pts/90, &detect_change);
if (detect_change) {
if (clr_x1 && clr_y1) {
fb->paintBox(clr_x0, clr_y0, clr_x1 + 1, clr_y1 + 1, 0);
clr_x0 = xres;
clr_y0 = yres;
clr_x1 = clr_y1 = 0;
}
while (image) {
if (last_color != image->color) {
last_color = image->color;
uint32_t c = last_color >> 8, a = 255 - (last_color & 0xff);
for (int i = 0; i < 256; i++) {
uint32_t k = (a * i) >> 8;
colortable[i] = k ? (c | (k << 24)) : 0;
}
}
if (image->w && image->h && image->dst_x > -1 && image->dst_x + image->w < xres && image->dst_y > -1 && image->dst_y + image->h < yres) {
if (image->dst_x < clr_x0)
clr_x0 = image->dst_x;
if (image->dst_y < clr_y0)
clr_y0 = image->dst_y;
if (image->dst_x + image->w > clr_x1)
clr_x1 = image->dst_x + image->w;
if (image->dst_y + image->h > clr_y1)
clr_y1 = image->dst_y + image->h;
uint32_t *lfb = fb->getFrameBufferPointer() + image->dst_x + xres * image->dst_y;
unsigned char *bm = image->bitmap;
int bm_add = image->stride - image->w;
int lfb_add = xres - image->w;
for (int y = 0; y < image->h; y++) {
for (int x = 0; x < image->w; x++) {
if (*bm)
*lfb = colortable[*bm];
lfb++, bm++;
}
lfb += lfb_add;
bm += bm_add;
}
}
image = image->next;
}
fb->getInstance()->blit();
}
continue;
} else {
if (clr_x1 && clr_y1) {
int main() {
Debug *debug;
debug = new Debug("TACTIC_GOAL");
debug->send("Tactic for Goal starting...");
IRSensor *ir[4];
ir[0] = new IRSensor("BALL_SENSOR4", "BALL_SENSORS", 4);
ir[1] = new IRSensor("BALL_SENSOR5", "BALL_SENSORS", 5);
ir[2] = new IRSensor("BALL_SENSOR6", "BALL_SENSORS", 6);
ir[3] = new IRSensor("BALL_SENSOR7", "BALL_SENSORS", 7);
Motion* motion;
motion = new Motion;
//Main Loop
while(true) {
if (ir[0]->getValue()) motion->drive(Vector(60,0), 0);
else motion->drive(Vector(0,0), 5);
}
// // position
// navi.calculate();
// Vector position = navi.getPosition();
// debug->send("X: %f|Y: %f", position.getX(), position.getY());
//
//
// // correct angle to zero degree
// turnto_count ++;
// if (turnto_count > TURNTO_COUNT_TRESHOLD && abs(gyro.getVector().getAngle(true, false)) > ANGLE_TRESHOLD) {
// motion->turnto(Vector(0,1), 30, Motion::automatic);
// turnto_count = 0;
// }
// //else {
// Vector drive(0, 0);
// if(ir[0]->getValue() < 30 && ir[1]->getValue() < 30 && ir[2]->getValue() < 30 && ir[3]->getValue() < 30) { // no ball --> adjustment
// //motion->pbreak();
// motion->drive(Vector(0,0), 0);
// ///debug->send("Ball not available - adjustment");
//
// /** adjustment **/
// if (position.getX() < X_TARGET - X_TOLLERANCE) drive.setX(1);
// else if (position.getX() > X_MAX + X_TOLLERANCE) drive.setX(-1);
//
// if (position.getY() < Y_TARGET - Y_TOLLERANCE) drive.setY(1);
// else if (position.getY() > Y_TARGET + Y_TOLLERANCE) drive.setY(-1);
//
// /// if already adjusted and no ball -> drive left - right to seek the ball
//
//
// drive.setLength(ADJUST_SPEED);
// motion->drive(drive, 0);
// }
// else {
// if(position.getY() > Y_MIN && (ir[3]->getValue() > (ir[0]->getValue() + ir[1]->getValue() + ir[2]->getValue())/3)) { // schraeg nach hinten
// debug->send("Ball is behind");
// drive.setY(-1);
//
// // schraeg, jenachdem wo mehr platz
// if (position.getX() > FIELD_WIDTH / 2) drive.setX(-1);
// else drive.setX(1);
//
// drive.setLength(BALL_SPEED);
// }
// else if(position.getY() < Y_MAX && (ir[0]->getValue() <= ir[1]->getValue() && ir[2]->getValue() <= ir[1]->getValue())) {
// debug->send("Ball is in front");
// drive.set(0, 1);
// drive.setLength(BALL_SPEED);
// }
// else if(position.getX() < X_MAX && (ir[0]->getValue() > ir[1]->getValue())) { // drive right
// debug->send("Ball is front right");
// //drive.set(1.5, 1);
// drive.set(1, 0);
// drive.setLength(BALL_SPEED);
// }
// else if(position.getX() > X_MIN && (ir[2]->getValue() > ir[1]->getValue())) { // drive left
// debug->send("Ball is front left");
// //drive.set(-1.5, 1);
// drive.set(-1, 0);
// drive.setLength(BALL_SPEED);
// }
//
// //debug->send("Drive vector: %f | %f %d", drive.getX(), drive.getY(), ir[1]->getValue());
//
// ///debug->send("%d\t%d\t%d\t%d", ir[0]->getValue(), ir[1]->getValue(), ir[2]->getValue(), ir[3]->getValue());
//
// motion->drive(drive, 0);
//
// }
// //}
//
// usleep(30000);
// }
//
}
void Util_Parser::llenarParametrosObtenidos( std::vector<YAML::Node> baseNode, Parametros ¶metrosObtenidos)
{
try
{
Debug debugParseado = read_yaml_Debug(baseNode);
parametrosObtenidos.level = debugParseado.get_level();
if(levelValido( parametrosObtenidos.level))
{
NotifyMessage("llenarParametrosObtenidos: level obtenido", "Util_Parser.cpp");
}
else
{
NotifyWarning("llenarParametrosObtenidos: level invalido", "Util_Parser.cpp");
parametrosObtenidos.esValido = 0;
}
}
catch(YAML::Exception ex)
{
NotifyError("llenarParametrosObtenidos: no se pudo obtener el nodo Debug", "Util_Parser.cpp");
parametrosObtenidos.esValido = 0;
}
catch(const std::runtime_error& re)
{
NotifyError("Error en Runtime: ", "Util_Parser.cpp");
NotifyError(re.what(), "Util_Parser.cpp");
parametrosObtenidos.esValido = 0;
}
catch(const std::exception& ex)
{
NotifyError("Ha ocurrido un error: ", "Util_Parser.cpp");
NotifyError(ex.what(), "Util_Parser.cpp");
parametrosObtenidos.esValido = 0;
}
catch(...)
{
NotifyError("Error desconocido que no se ha podido especificar.", "Util_Parser.cpp");
parametrosObtenidos.esValido = 0;
}
try
{
Equipo equipoParseado = read_yaml_Equipo(baseNode);
parametrosObtenidos.casaca = equipoParseado.get_casaca();
if(casacaValido(parametrosObtenidos.casaca))
{
NotifyMessage("llenarParametrosObtenidos: casaca obtenido", "Util_Parser.cpp");
}
else
{
NotifyWarning("llenarParametrosObtenidos: casaca invalido", "Util_Parser.cpp");
parametrosObtenidos.esValido = 0;
}
parametrosObtenidos.formacion = equipoParseado.get_formacion();
if(formacionValido(parametrosObtenidos.formacion))
{
NotifyMessage("llenarParametrosObtenidos: formacion obtenido", "Util_Parser.cpp");
}
else
{
NotifyWarning("llenarParametrosObtenidos: formacion invalido", "Util_Parser.cpp");
parametrosObtenidos.esValido = 0;
}
}
catch(YAML::Exception ex)
{
NotifyError("llenarParametrosObtenidos: no se pudo obtener el nodo Equipo", "Util_Parser.cpp");
parametrosObtenidos.esValido = 0;
}
catch(const std::runtime_error& re)
{
NotifyError("Error en Runtime: ", "Util_Parser.cpp");
NotifyError(re.what(), "Util_Parser.cpp");
parametrosObtenidos.esValido = 0;
}
catch(const std::exception& ex)
{
NotifyError("Ha ocurrido un error: ", "Util_Parser.cpp");
NotifyError(ex.what(), "Util_Parser.cpp");
parametrosObtenidos.esValido = 0;
}
catch(...)
{
NotifyError("Error desconocido que no se ha podido especificar.", "Util_Parser.cpp");
parametrosObtenidos.esValido = 0;
}
}
int main () {
try {
Debug debug ("CAN_SERVER");
debug.send("debug->initialisation");
std::cout << "can-server -> initialisation ..." << std::endl;
BufferedAsyncSerial serial(SERIAL_DEVICE_FILE.c_str(), SERIAL_BAUD_RATE);
if (!serial.isOpen()) {
std::cerr << "ERROR: could not open serial Stream to :" << SERIAL_DEVICE_FILE << std::endl;
debug.send("ERROR: could not open serial stream to: %s", SERIAL_DEVICE_FILE.c_str());
}
ipcReceivingConnection ipcRCon ("CAN_SERVER", 10, 32);
CANConfig cancfg(CAN_CONFIG_FILE_PATH.c_str());
std::string serial_buffer;
Data* ipc_buffer;
while(true) {
if (serial.readsome(serial_buffer, 11)) { /// new serial message ... /** asynchronous readsome function, must be called in loop ! **/
debug.send("serial data received: %s", serial_buffer.c_str());
std::cout << "received new serialdata: " << serial_buffer << std::endl;
/*for (int i = 0; i < 11; i++) {
std::cout << "[" << i << "]: " << int(serial_buffer[i]) << std::endl;
}*/
//bool can_rtr = serial_buffer[0];
unsigned short can_id = serial_buffer[1];
//unsigned short can_length = serial_buffer[2];
//char can_data[can_length];
//for (int i = 0; i < can_length; i++) can_data[i] = serial_buffer[3+i];
char can_data[8];
for (int i = 0; i < 8; i++) can_data[i] = serial_buffer[3+i];
std::string ipc_output ((char*)&can_id);
ipc_output += std::string(can_data, 8);
/*std::cout << "can_id: " << int(can_id) << std::endl;
std::cout << "\ncan_data: \t";
for (int i = 0; i < 8; i++) std::cout << int(can_data[i]) << "\t";
std::cout << "\nipc_output: \t";
for (unsigned int i = 0; i < ipc_output.length(); i ++) std::cout << int(ipc_output[i]) << "\t";
std::cout << std::endl;*/
//std::cout << "can_data: " << int(can_data) << std::endl;
//std::cout << "ipc_output: " << int(ipc_output) << std::endl;
std::string ipcSyn = cancfg.getIpcSynonym(can_id);
std::cout << "ipcSyn: " << ipcSyn << std::endl;
ipcSendingConnection ipcSCon("CAN_SERVER", ipcSyn, 32, IPC_LOCAL);
//if (ipcSCon.is_open()) {
ipcSCon.sendData(ipc_output);
//}
/*else { /// could not open ipc_connection
std::cerr << "ERROR: could not open ipc_connection to: " << ipcSyn << std::endl;
debug.send("ERROR: could not open ipc_connection to: %s", ipcSyn.c_str());
}*/
}
if (ipcRCon.checkForNewData()) { /// new ipc data available ...
ipc_buffer = ipcRCon.readDataFromBuffer();
std::string data = ipc_buffer->getData();
data.resize(12, 0);
short senderID = ipc_buffer->getSenderID();
debug.send("data: %s\tsenderID: %i", data.c_str(), senderID);
std::cout << "data[0]: " << (int)data[0] << "\tsenderID: " << senderID << std::endl;
char command = data[0];
data.erase(0,1);
/*if (command == '') { /// remote call
unsigned short can_id = cancfg.getCanID(data);
char serial_data[12];
serial_data[0] = 's';
serial_data[1] = 1;
serial_data[2] = can_id;
serial_data[3] = 0;
for (int i = 0; i < 8; i++) serial_data[4+i] = 0; // sets the values of the CAN data to ZERO, only rtr is important !
serial.write(serial_data, 12);
}*/
if (command == 's') { /// send data via CAN
unsigned short can_id = data[0];
std::cout << "can_id: " << can_id << std::endl;
data.erase(0, 1);
char serial_data[12];
serial_data[0] = 's';
serial_data[1] = 0;
serial_data[2] = can_id;
serial_data[3] = 8;
for (int i = 0; i < 8; i++) serial_data[4+i] = data[i];
std::cout << "send data via can now: " << std::endl;
for (int i = 0; i < 12; i++) {
//printf("%i: %c", i, serial_data[i]);
std::cout << "i: " << i << "\t" << int(serial_data[i]) << std::endl;
}
//serial.write(serial_data, 12);
for (int i = 0; i < 12; i++) {
serial.write(serial_data+i, 1);
usleep(5);
}
}
else if (command == 'f') { /// set filter
unsigned int num = data[0];
unsigned int mask = data[1];
unsigned int id = data[2];
char serial_data[12];
serial_data[0] = 'f'; /// 'f' for "set filter"
serial_data[1] = num; /// num
serial_data[2] = id; /// id
serial_data[3] = mask; /// mask
serial_data[4] = 0; /// rtr
for (int i = 0; i < 7; i++) serial_data[5+i] = 0;
serial.write(serial_data, 12);
}
else {
std::cerr << "ERROR: unknown command byte (IPC): " << command << std::endl;
debug.send("ERROR: unknown command byte (IPC): %c", command);
}
}
}
serial.close();
}
catch(boost::system::system_error& e) {
std::cerr << "Error: " << e.what() << std::endl;
return 1;
}
}
