Remove comments

Author: Jean-Romain

src/drawer.cpp

@@ -566,7 +566,6 @@ void Drawer::traverse_and_collect(const Key& key, std::vector<Node*>& visible_oc
   }
 }
 
-
 void Drawer::query_rendered_point()
 {
   pp.clear();
@@ -584,187 +583,3 @@ void Drawer::setPointSize(float size)
 {
   if (size > 0) this->point_size = size;
 }
-
-
-/*if (postprod)
- {
- std::vector<unsigned char> pixelData(width * height * 4); // Assuming RGBA
- glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixelData.data());
-
- // Step 3: Identify and fill holes
- int maxIterations = 5; // Number of passes to make
- for (int iter = 0; iter < maxIterations; ++iter) {
- for (int y = WS; y < height - WS; ++y) {
- for (int x = WS; x < width - WS; ++x) {
- int index = (y * width + x) * 4;
- if (isBackgroundPixel(pixelData[index], pixelData[index + 1], pixelData[index + 2], pixelData[index + 3]))
- {
- //pixelData[index] = 0; pixelData[index + 1] = 255; pixelData[index + 2] = 0;
- if (hasSurroundingForegroundPixels(pixelData, x, y, width)) {
- //pixelData[index] = 255; pixelData[index + 1] = 255; pixelData[index + 2] = 255;
- fillHole(pixelData, x, y, width);
- }
- }
- }
- }
- }
-
- glDrawPixels(width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixelData.data());
- }*/
-
-
-// depth-buffer edge detection
-/*std::vector< GLfloat > depth( width * height, 0 );
- glReadPixels( 0, 0, width, height, GL_DEPTH_COMPONENT, GL_FLOAT, &depth[0] );
-
- // Linearize depth and convert to unsigned byte
- std::vector<GLubyte> depthImage(width * height);
- for (size_t i = 0; i < depth.size(); ++i) {
- float linearDepth = (2.0f * zNear) / (zFar + zNear - depth[i] * (zFar - zNear));
- depthImage[i] = static_cast<GLubyte>(linearDepth * 255.0f);  // Map to [0, 255]
- }
-
- int Gx[3][3] = {
- {-1, 0, 1},
- {-2, 0, 2},
- {-1, 0, 1}
- };
-
- int Gy[3][3] = {
- {-1, -2, -1},
- { 0,  0,  0},
- { 1,  2,  1}
- };
-
- std::vector<GLubyte> edgeImage(width * height, 0);
-
- for (int y = 1; y < height - 1; ++y) {
- for (int x = 1; x < width - 1; ++x) {
- float gx = 0.0f;
- float gy = 0.0f;
-
- for (int i = -1; i <= 1; ++i) {
- for (int j = -1; j <= 1; ++j) {
- gx += Gx[i + 1][j + 1] * depthImage[(y + i) * width + (x + j)];
- gy += Gy[i + 1][j + 1] * depthImage[(y + i) * width + (x + j)];
- }
- }
-
- float gradient = sqrt(gx * gx + gy * gy);
- edgeImage[y * width + x] = static_cast<GLubyte>(std::min(gradient, 255.0f)); // Clamp to [0, 255]
- }
- }
-
- // Step 4: Replace values >= 255 with 0
- for (size_t i = 0; i < edgeImage.size(); ++i) {
- if (edgeImage[i] >= 220) {
- edgeImage[i] = 0;
- }
- }
-
- // Step 5: Find the new maximum value
- GLubyte newMaxValue = 0;
- for (size_t i = 0; i < edgeImage.size(); ++i) {
- if (edgeImage[i] > newMaxValue) {
- newMaxValue = edgeImage[i];
- }
- }
-
- // Step 6: Rescale the image to the range [0, 255]
- if (newMaxValue > 0) {  // Avoid division by zero
- for (size_t i = 0; i < edgeImage.size(); ++i) {
- edgeImage[i] = static_cast<GLubyte>((edgeImage[i] * 255.0f) / newMaxValue);
- }
- }
-
- // Step 7: Create the shadow image
- std::vector<GLubyte> shadowImage(width * height * 4, 0);  // Initialize as white with full alpha
-
- for (int y = 0; y < height; ++y) {
- for (int x = 0; x < width; ++x) {
- size_t index = y * width + x;
- if (edgeImage[index] == 0) {
- // Set to black with some alpha value (e.g., 128 for semi-transparency)
- shadowImage[index * 4 + 0] = 0;
- shadowImage[index * 4 + 1] = 0;
- shadowImage[index * 4 + 2] = 0;
- shadowImage[index * 4 + 3] = 128;  // Alpha value (0-255, where 0 is fully transparent and 255 is fully opaque)
- }
- }
- }
-
- // Step 8: Enable blending and set blend function
- glEnable(GL_BLEND);
- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
- // Step 9: Render the shadow image
- glDrawPixels(width, height, GL_RGBA, GL_UNSIGNED_BYTE, shadowImage.data());
- */
-
-/*
- * #define WS 5
-
- bool isBackgroundPixel(unsigned char r, unsigned char g, unsigned char b, unsigned char a) {
- // Define what you consider as a background pixel.
- // Example: A black pixel with full transparency.
- return (r < 200 && g < 200 && b < 200);
- }
-
- bool hasSurroundingForegroundPixels(const std::vector<unsigned char>& pixelData, int x, int y, int width) {
- int offsets[] = {-WS, 0, WS};  // To iterate over neighboring pixels
- int n = 0;
- for (int dy : offsets) {
- for (int dx : offsets) {
- if (dx == 0 && dy == 0) continue; // Skip the center pixel itself
-
- int neighborIndex = ((y + dy) * width + (x + dx)) * 4; // Calculate neighbor's index in the array
- unsigned char r = pixelData[neighborIndex];
- unsigned char g = pixelData[neighborIndex + 1];
- unsigned char b = pixelData[neighborIndex + 2];
- unsigned char a = pixelData[neighborIndex + 3];
-
- if (!isBackgroundPixel(r, g, b, a)) {
- n++;
- }
- }
- }
- if (n >= 8) return true;
- return false; // No foreground pixels around
- }
-
- void fillHole(std::vector<unsigned char>& pixelData, int x, int y, int width) {
- int offsets[] = {-WS, 0, WS};  // To iterate over neighboring pixels
- int rSum = 0, gSum = 0, bSum = 0, aSum = 0;
- int count = 0;
-
- // Calculate the sum of the colors of the surrounding foreground pixels
- for (int dy : offsets) {
- for (int dx : offsets) {
- if (dx == 0 && dy == 0) continue; // Skip the center pixel itself
-
- int neighborIndex = ((y + dy) * width + (x + dx)) * 4;
- unsigned char r = pixelData[neighborIndex];
- unsigned char g = pixelData[neighborIndex + 1];
- unsigned char b = pixelData[neighborIndex + 2];
- unsigned char a = pixelData[neighborIndex + 3];
-
- if (!isBackgroundPixel(r, g, b, a)) {
- rSum += r;
- gSum += g;
- bSum += b;
- aSum += a;
- count++;
- }
- }
- }
-
- // Avoid division by zero
- if (count > 0) {
- int index = (y * width + x) * 4;
- pixelData[index]     = rSum / count;
- pixelData[index + 1] = gSum / count;
- pixelData[index + 2] = bSum / count;
- pixelData[index + 3] = aSum / count;
- }
- }*/
-

src/lidRviewer.cpp

@@ -173,149 +173,3 @@ void viewer(DataFrame df, std::string hnof)
   sdl_thread.detach();  // Detach the thread to allow it to run independently
   running = true;
 }
-
-
-/*void viewer(DataFrame df)
-{
-  bool run = true;
-
-  SDL_Event event;
-
-  unsigned int width = 600;
-  unsigned int height = 600;
-
-  Uint32 last_time, current_time, elapsed_time;
-
-  SDL_Init(SDL_INIT_VIDEO);
-  SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-  SDL_Window *window = SDL_CreateWindow("lidRviewer", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
-
-  SDL_GLContext glContext = SDL_GL_CreateContext(window);
-  SDL_GL_SetSwapInterval(1); // Enable VSync
-
-  glMatrixMode(GL_PROJECTION);
-  glLoadIdentity();
-  gluPerspective(70, (double)width / height, zNear, zFar);
-
-  glEnable(GL_DEPTH_TEST);              // Enable depth testing for z-culling
-  glDepthFunc(GL_LEQUAL);               // Set the type of depth-test
-  glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Nice perspective corrections
-
-
-  glEnable(GL_POINT_SMOOTH);   // Round point
-
-  glEnable(GL_LINE_SMOOTH);   // Enable line anti-aliasing
-  glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
-
-  //glEnable(GL_MULTISAMPLE);
-  //glHint(GL_MULTISAMPLE_FILTER_HINT_NV, GL_NICEST);
-
-  //glEnable(GL_VERTEX_PROGRAM_POINT_SIZE); // Enable changing the point size
-
-  Drawer *drawer = new Drawer(window, df);
-  drawer->camera.setRotateSensivity(0.1);
-  drawer->camera.setZoomSensivity(10);
-  drawer->camera.setPanSensivity(1);
-  drawer->setPointSize(4);
-
-
-  last_time = SDL_GetTicks();
-
-  while (run)
-  {
-    while (SDL_PollEvent(&event))
-    {
-      switch (event.type)
-      {
-      case SDL_QUIT:
-        run = false;
-        break;
-
-      case SDL_KEYDOWN:
-        switch (event.key.keysym.sym)
-        {
-        case SDLK_ESCAPE:
-          run = false;
-          break;
-        case SDLK_z:
-          drawer->setAttribute(Attribute::Z);
-          break;
-        case SDLK_i:
-          drawer->setAttribute(Attribute::I);
-          break;
-        case SDLK_c:
-          drawer->setAttribute(Attribute::CLASS);
-          break;
-        case SDLK_r:
-        case SDLK_g:
-        case SDLK_b:
-          drawer->setAttribute(Attribute::RGB);
-          break;
-        case SDLK_q:
-          drawer->display_hide_spatial_index();
-          break;
-        case SDLK_l:
-          drawer->display_hide_edl();
-          break;
-        case SDLK_PLUS:
-        case SDLK_KP_PLUS:
-          drawer->point_size_plus();
-          break;
-        case SDLK_MINUS:
-        case SDLK_KP_MINUS:
-          drawer->point_size_minus();
-          break;
-        default:
-          drawer->camera.OnKeyboard(event.key);
-        break;
-        }
-        break;
-
-      case SDL_MOUSEMOTION:
-        drawer->camera.OnMouseMotion(event.motion);
-        break;
-
-      case SDL_MOUSEBUTTONUP:
-      case SDL_MOUSEBUTTONDOWN:
-        drawer->camera.OnMouseEvent(event.button, SDL_MouseWheelEvent{}); // Pass an empty SDL_MouseWheelEvent
-        break;
-
-      case SDL_MOUSEWHEEL:
-        drawer->camera.OnMouseEvent(SDL_MouseButtonEvent{}, event.wheel); // Pass an empty SDL_MouseButtonEvent
-        break;
-
-      case SDL_WINDOWEVENT:
-        if (event.window.event == SDL_WINDOWEVENT_RESIZED)
-        {
-          width = event.window.data1;
-          height = event.window.data2;
-          glViewport(0, 0, width, height);
-          glMatrixMode(GL_PROJECTION);
-          glLoadIdentity();
-          gluPerspective(70, (double)width / height, zNear, zFar);
-          drawer->camera.changed = true;
-        }
-        break;
-      }
-    }
-
-    current_time = SDL_GetTicks();
-    elapsed_time = current_time - last_time;
-
-    if (elapsed_time > time_per_frame)
-    {
-      drawer->draw();
-      last_time = current_time;
-    }
-    else
-    {
-      SDL_Delay(time_per_frame - elapsed_time);
-    }
-  }
-
-  delete drawer;
-  SDL_GL_DeleteContext(glContext); // Correctly delete OpenGL context
-  SDL_DestroyWindow(window); // Correctly destroy window
-  SDL_Quit();
-  return;
-}*/