try build

.gitea/workflows/run_build.yaml

@@ -0,0 +1,20 @@
+name: Run Build
+run-name: ${{ gitea.actor }} is building tview
+on: [push]
+
+jobs:
+  run-builds:
+    name: Run build
+    container:
+      image: ubuntu:latest
+      steps:
+        - name: Checkout repo
+          uses: actions/checkout@v2
+        - name: Run ls
+          run: ls
+        - name: Install things
+          run: apt update && apt install build-essential cmake libsdl2-dev libexiv2-dev mesa-utils
+        - name: Generate
+          run: cmake .
+        - name: Build
+          run: cmake --build .

.gitignore

@@ -31,5 +31,21 @@
 *.out
 *.app
 
+imgui.ini
 
 tview
+
+#CMake
+CMakeLists.txt.user
+CMakeCache.txt
+CMakeFiles
+CMakeScripts
+Testing
+Makefile
+cmake_install.cmake
+install_manifest.txt
+compile_commands.json
+CTestTestfile.cmake
+_deps
+CMakeUserPresets.json
+

CMakeLists.txt

@@ -0,0 +1,50 @@
+cmake_minimum_required(VERSION 3.10)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+
+project(tview)
+
+set (SOURCES
+lib/backends/imgui_impl_opengl3.cpp
+lib/backends/imgui_impl_opengl3.h
+lib/backends/imgui_impl_opengl3_loader.h
+lib/backends/imgui_impl_sdl2.cpp
+lib/backends/imgui_impl_sdl2.h
+lib/backends/tex_inspect_opengl.h
+lib/backends/tex_inspect_opengl.cpp
+lib/context_wrapper.h
+lib/image_model.h
+lib/imconfig.h
+lib/imfilebrowser.h
+lib/imgui.cpp
+lib/imgui.h
+lib/imgui_bezier_math.h
+lib/imgui_bezier_math.inl
+lib/imgui_demo.cpp
+lib/imgui_draw.cpp
+lib/imgui_extra_math.h
+lib/imgui_extra_math.inl
+lib/imgui_internal.h
+lib/imgui_tables.cpp
+lib/imgui_widgets.cpp
+lib/imstb_rectpack.h
+lib/imstb_textedit.h
+lib/imstb_truetype.h
+lib/stb_image.h
+lib/imgui_tex_inspect.h
+lib/imgui_tex_inspect_internal.h
+lib/imgui_tex_inspect.cpp
+lib/argparse.hpp
+lib/histogram.h
+main.cpp
+)
+
+set(OpenGL_GL_PREFERENCE GLVND)
+find_package(SDL2 REQUIRED)
+find_package(OpenGL REQUIRED)
+find_package(exiv2 REQUIRED)
+include_directories(${SDL2_INCLUDE_DIRS} ${OPENGL_INCLUDE_DIRS})
+
+add_executable(tview ${SOURCES})
+target_link_libraries(tview ${SDL2_LIBRARIES} ${OPENGL_LIBRARIES} exiv2lib)

Makefile

@@ -1,91 +0,0 @@
-#
-# Cross Platform Makefile
-# Compatible with MSYS2/MINGW, Ubuntu 14.04.1 and Mac OS X
-#
-# You will need SDL2 (http://www.libsdl.org):
-# Linux:
-#   apt-get install libsdl2-dev
-# Mac OS X:
-#   brew install sdl2
-# MSYS2:
-#   pacman -S mingw-w64-i686-SDL2
-#
-
-#CXX = g++
-#CXX = clang++
-
-EXE = tview
-IMGUI_DIR = lib
-SOURCES = main.cpp
-SOURCES += $(wildcard $(IMGUI_DIR)/*.cpp)
-SOURCES += $(wildcard $(IMGUI_DIR)/backends/*.cpp)
-OBJS = $(addsuffix .o, $(basename $(notdir $(SOURCES))))
-UNAME_S := $(shell uname -s)
-LINUX_GL_LIBS = -lGL
-
-CXXFLAGS = -std=c++20 -I$(IMGUI_DIR) -I$(IMGUI_DIR)/backends
-CXXFLAGS += -DIMGUI_DEFINE_MATH_OPERATORS -Ofast
-LIBS =
-
-##---------------------------------------------------------------------
-## OPENGL ES
-##---------------------------------------------------------------------
-
-## This assumes a GL ES library available in the system, e.g. libGLESv2.so
-# CXXFLAGS += -DIMGUI_IMPL_OPENGL_ES2
-# LINUX_GL_LIBS = -lGLESv2
-## If you're on a Raspberry Pi and want to use the legacy drivers,
-## use the following instead:
-# LINUX_GL_LIBS = -L/opt/vc/lib -lbrcmGLESv2
-
-##---------------------------------------------------------------------
-## BUILD FLAGS PER PLATFORM
-##---------------------------------------------------------------------
-
-ifeq ($(UNAME_S), Linux) #LINUX
-	ECHO_MESSAGE = "Linux"
-	LIBS += $(LINUX_GL_LIBS) -ldl `sdl2-config --libs`
-
-	CXXFLAGS += `sdl2-config --cflags`
-	CFLAGS = $(CXXFLAGS)
-endif
-
-ifeq ($(UNAME_S), Darwin) #APPLE
-	ECHO_MESSAGE = "Mac OS X"
-	LIBS += -framework OpenGL -framework Cocoa -framework IOKit -framework CoreVideo `sdl2-config --libs`
-	LIBS += -L/usr/local/lib -L/opt/local/lib
-
-	CXXFLAGS += `sdl2-config --cflags`
-	CXXFLAGS += -I/usr/local/include -I/opt/local/include
-	CFLAGS = $(CXXFLAGS)
-endif
-
-ifeq ($(OS), Windows_NT)
-    ECHO_MESSAGE = "MinGW"
-    LIBS += -lgdi32 -lopengl32 -limm32 `pkg-config --static --libs sdl2`
-
-    CXXFLAGS += `pkg-config --cflags sdl2`
-    CFLAGS = $(CXXFLAGS)
-endif
-
-##---------------------------------------------------------------------
-## BUILD RULES
-##---------------------------------------------------------------------
-
-%.o:%.cpp
-	$(CXX) $(CXXFLAGS) -c -o $@ $<
-
-%.o:$(IMGUI_DIR)/%.cpp
-	$(CXX) $(CXXFLAGS) -c -o $@ $<
-
-%.o:$(IMGUI_DIR)/backends/%.cpp
-	$(CXX) $(CXXFLAGS) -c -o $@ $<
-
-all: $(EXE)
-	@echo Build complete for $(ECHO_MESSAGE)
-
-$(EXE): $(OBJS)
-	$(CXX) -o $@ $^ $(CXXFLAGS) $(LIBS)
-
-clean:
-	rm -f $(EXE) $(OBJS)

imgui.ini

@@ -1,24 +0,0 @@
-[Window][Debug##Default]
-Pos=341,6
-Size=400,400
-Collapsed=0
-
-[Window][viewport_container]
-Size=1101,598
-Collapsed=0
-
-[Window][Editor]
-Pos=33,52
-Size=1118,634
-Collapsed=0
-
-[Window][Main]
-Pos=0,0
-Size=1654,1186
-Collapsed=0
-
-[Window][Help]
-Pos=136,255
-Size=177,114
-Collapsed=0
-

lib/backends/tex_inspect_opengl.cpp

@@ -77,11 +77,16 @@ using namespace gl;
 #elif defined(IMGUI_IMPL_OPENGL_LOADER_EPOXY)
 #include <epoxy/gl.h>
 #else
+#if defined(__APPLE__)
+#include <OpenGL/gl.h>
+#include <OpenGL/gl3.h>
+#else
 #include <SDL2/SDL_opengl.h>
 #include <SDL2/SDL_opengles2.h>
 #include <SDL2/SDL_opengles2_gl2.h>
 #endif
 #endif
+#endif
 
 // Desktop GL 3.2+ has glDrawElementsBaseVertex() which GL ES and WebGL don't have.
 #if !defined(IMGUI_IMPL_OPENGL_ES2) && !defined(IMGUI_IMPL_OPENGL_ES3) && defined(GL_VERSION_3_2)

lib/histogram.h

@@ -0,0 +1,88 @@
+#include <cstdint>
+#include "./imgui.h"
+#include "./imgui_internal.h"
+
+class Histogram {
+
+public:
+  unsigned int count[4][256] = {0};
+  int width;
+  int height;
+  int channels;
+
+  Histogram(int width, int height, int channels) {
+    this->width = width;
+    this->height = height;
+    this->channels = channels;
+  }
+
+  void Load(uint8_t * image) {
+    for (int l = 0; l < height * width; l++)
+    {
+      count[0][*image++]++;
+      count[1][*image++]++;
+      count[2][*image++]++;
+      count[3][*image++]++;
+    }
+  };
+
+  void Draw() {
+    ImGui::InvisibleButton("histogram", ImVec2(512, 256));
+
+    unsigned int maxv = count[0][0];
+    unsigned int* pCount = &count[0][0];
+    for (int i = 0; i < 3 * 256; i++, pCount++)
+    {
+      maxv = (maxv > *pCount) ? maxv : *pCount;
+    }
+
+    ImDrawList* drawList = ImGui::GetWindowDrawList();
+    const ImVec2 rmin = ImGui::GetItemRectMin();
+    const ImVec2 rmax = ImGui::GetItemRectMax();
+    const ImVec2 size = ImGui::GetItemRectSize();
+    const float hFactor = size.y / float(maxv);
+
+    for (int i = 0; i <= 10; i++)
+    {
+      float ax = rmin.x + (size.x / 10.f) * float(i);
+      float ay = rmin.y + (size.y / 10.f) * float(i);
+      drawList->AddLine(ImVec2(rmin.x, ay), ImVec2(rmax.x, ay), 0x80808080);
+      drawList->AddLine(ImVec2(ax, rmin.y), ImVec2(ax, rmax.y), 0x80808080);
+    }
+
+    const float barWidth = (size.x / 256.f);
+    for (int j = 0; j < 256; j++)
+    {
+      // pixel count << 2 + color index(on 2 bits)
+      uint32_t cols[3] = {(count[0][j] << 2), (count[1][j] << 2) + 1, (count[2][j] << 2) + 2};
+      if (cols[0] > cols[1])
+        ImSwap(cols[0], cols[1]);
+      if (cols[1] > cols[2])
+        ImSwap(cols[1], cols[2]);
+      if (cols[0] > cols[1])
+        ImSwap(cols[0], cols[1]);
+      float heights[3];
+      uint32_t colors[3];
+      uint32_t currentColor = 0xFFFFFFFF;
+      for (int i = 0; i < 3; i++)
+      {
+        heights[i] = rmax.y - (cols[i] >> 2) * hFactor;
+        colors[i] = currentColor;
+        currentColor -= 0xFF << ((cols[i] & 3) * 8);
+      }
+
+      float currentHeight = rmax.y;
+      const float left = rmin.x + barWidth * float(j);
+      const float right = left + barWidth;
+      for (int i = 0; i < 3; i++)
+      {
+        if (heights[i] >= currentHeight)
+        {
+          continue;
+        }
+        drawList->AddRectFilled(ImVec2(left, currentHeight), ImVec2(right, heights[i]), colors[i]);
+        currentHeight = heights[i];
+      }
+    }
+  };
+};

lib/uuid.cpp

@@ -1,35 +0,0 @@
-#include "uuid.h"
-
-namespace uuid {
-static std::random_device rd;
-static std::mt19937 gen(rd());
-static std::uniform_int_distribution<> dis(0, 15);
-static std::uniform_int_distribution<> dis2(8, 11);
-
-std::string generate_uuid_v4() {
-  std::stringstream ss;
-  int i;
-  ss << std::hex;
-  for (i = 0; i < 8; i++) {
-    ss << dis(gen);
-  }
-  ss << "-";
-  for (i = 0; i < 4; i++) {
-    ss << dis(gen);
-  }
-  ss << "-4";
-  for (i = 0; i < 3; i++) {
-    ss << dis(gen);
-  }
-  ss << "-";
-  ss << dis2(gen);
-  for (i = 0; i < 3; i++) {
-    ss << dis(gen);
-  }
-  ss << "-";
-  for (i = 0; i < 12; i++) {
-    ss << dis(gen);
-  };
-  return ss.str();
-}
-} // namespace uuid

lib/uuid.h

@@ -1,12 +0,0 @@
-#ifndef UUID_H
-#define UUID_H
-
-#include <random>
-#include <sstream>
-#include <string>
-
-namespace uuid {
-std::string generate_uuid_v4();
-}
-
-#endif // UUID_H

main.cpp

@@ -1,14 +1,3 @@
-// Dear ImGui: standalone example application for SDL2 + OpenGL
-// (SDL is a cross-platform general purpose library for handling windows,
-// inputs, OpenGL/Vulkan/Metal graphics context creation, etc.)
-
-// Learn about Dear ImGui:
-// - FAQ                  https://dearimgui.com/faq
-// - Getting Started      https://dearimgui.com/getting-started
-// - Documentation        https://dearimgui.com/docs (same as your local docs/
-// folder).
-// - Introduction, links and more at the top of imgui.cpp
-
 #include <SDL2/SDL_events.h>
 #include <SDL2/SDL_scancode.h>
 #include <cstddef>
@@ -17,6 +6,8 @@
 #include "lib/backends/imgui_impl_sdl2.h"
 #include "lib/imgui.h"
 #include "lib/imgui_internal.h"
+#include <cstdint>
+#include <exiv2/tags.hpp>
 #include <iostream>
 #include <stdexcept>
 #include <stdio.h>
@@ -44,29 +35,143 @@
 #include "lib/backends/tex_inspect_opengl.h"
 #include "lib/argparse.hpp"
 
+#include <exiv2/exiv2.hpp>
+
+#include "lib/histogram.h"
+
 struct Args : public argparse::Args {
   std::string &fpath = arg("path to the image");
 };
 
+
+struct EXIFData {
+  std::string CameraMake;
+  std::string CameraModel;
+  std::string LensModel;
+  std::string ImageOrientation;
+  std::string ImageDimensionX;
+  std::string ImageDimensiony;
+  std::string ISO;
+  std::string ShutterSpeed;
+  std::string FNumber;
+  std::string FocalLength;
+  std::string ExposureBias;
+  std::string MeteringMode;
+  std::string Flash;
+  std::string Time;
+  std::string TimeTaken;
+  std::string TimeTakenOffset;
+  std::string GPSLat;
+  std::string GPSLatref;
+  std::string GPSLon;
+  std::string GPSLonref;
+};
+
 struct Texture
 {
     ImTextureID texture;
     ImVec2 size;
+    int channels;
+    EXIFData exif;
 };
 
-Texture LoadTexture(const char * path)
-{
-    const int channelCount = 4;
-    int imageFileChannelCount;
-    int width, height;
-    uint8_t *image = (uint8_t *)stbi_load(path, &width, &height, &imageFileChannelCount, channelCount);
-    if (image == NULL)
-    {
-        fprintf(stderr, "%s\nFailed to open %s\n", stbi_failure_reason(), path);
+static uint8_t* image = nullptr;
 
-        return {nullptr,{0,0}};
+
+EXIFData printExifData(const std::string& imagePath) {
+    EXIFData d;
+    d.CameraMake = "NULL";
+    try {
+        // Load the image
+        Exiv2::Image::UniquePtr img = Exiv2::ImageFactory::open(imagePath);
+        if (img.get() == 0) {
+            std::cerr << "Error: Could not open image file " << imagePath << std::endl;
+            return d;
+        }
+        img->readMetadata();
+
+        // Get the Exif data
+        Exiv2::ExifData &exifData = img->exifData();
+        if (exifData.empty()) {
+            std::cerr << "No EXIF data found in file " << imagePath << std::endl;
+            return d;
+        }
+
+        // Helper function to print EXIF data if available
+        auto printExifValue = [&exifData](const char* key, std::string *d) {
+            Exiv2::ExifKey exifKey(key);
+            Exiv2::ExifData::const_iterator pos = exifData.findKey(exifKey);
+            if (pos != exifData.end()) {
+                *d = pos->value().toString();
+            }
+        };
+
+        // Print common EXIF data
+        printExifValue("Exif.Image.Make", &d.CameraMake);
+        printExifValue("Exif.Image.Model", &d.CameraModel);
+        printExifValue("Exif.Photo.LensModel", &d.LensModel);
+
+        printExifValue("Exif.Image.Orientation", &d.ImageOrientation);
+    //
+        printExifValue("Exif.Photo.ExposureTime", &d.ShutterSpeed);
+        printExifValue("Exif.Photo.FNumber", &d.FNumber);
+        printExifValue("Exif.Photo.ISOSpeedRatings", &d.ISO);
+        printExifValue("Exif.Photo.FocalLength", &d.FocalLength);
+        printExifValue("Exif.Photo.ExposureBiasValue", &d.ExposureBias);
+        printExifValue("Exif.Photo.MeteringMode", &d.MeteringMode);
+        printExifValue("Exif.Photo.Flash", &d.Flash);
+
+        printExifValue("Exif.Image.DateTime", &d.Time);
+        printExifValue("Exif.Photo.DateTimeOriginal", &d.TimeTaken);
+        printExifValue("Exif.Photo.OffsetTime", &d.TimeTakenOffset);
+        printExifValue("Exif.Photo.PixelXDimension", &d.ImageDimensionX);
+        printExifValue("Exif.Photo.PixelYDimension", &d.ImageDimensiony);
+
+        printExifValue("Exif.GPSInfo.GPSLatitudeRef", &d.GPSLatref);
+        printExifValue("Exif.GPSInfo.GPSLatitude", &d.GPSLat);
+        printExifValue("Exif.GPSInfo.GPSLongitudeRef", &d.GPSLonref);
+        printExifValue("Exif.GPSInfo.GPSLongitude", &d.GPSLon);
+
+
+/*
+Exif.Image.Make                              0x010f Ascii       5  SONY
+Exif.Image.Model                             0x0110 Ascii      10  ILCE-7RM5
+
+Exif.Image.Orientation                       0x0112 Short       1  8
+Exif.Photo.PixelXDimension                   0xa002 Long        1  9504
+Exif.Photo.PixelYDimension                   0xa003 Long        1  6336
+
+Exif.Photo.ExposureTime                      0x829a Rational    1  1/400
+Exif.Photo.FNumber                           0x829d Rational    1  56/10
+Exif.Photo.ISOSpeedRatings                   0x8827 Short       1  100
+Exif.Photo.FocalLength                       0x920a Rational    1  400/10
+Exif.Photo.ExposureBiasValue                 0x9204 SRational   1  -10/10
+Exif.Photo.MeteringMode                      0x9207 Short       1  5
+Exif.Photo.Flash                             0x9209 Short       1  16
+
+Exif.Image.DateTime                          0x0132 Ascii      20  2024:06:07 08:58:07
+Exif.Photo.DateTimeOriginal                  0x9003 Ascii      20  2024:06:07 08:58:07
+Exif.Photo.OffsetTime                        0x9010 Ascii       7  -05:00
+
+Exif.GPSInfo.GPSLatitudeRef                  0x0001 Ascii       2  N
+Exif.GPSInfo.GPSLatitude                     0x0002 Rational    3  40/1 43/1 32231/1000
+Exif.GPSInfo.GPSLongitudeRef                 0x0003 Ascii       2  W
+Exif.GPSInfo.GPSLongitude                    0x0004 Rational    3  73/1 59/1 16688/1000
+*/
+
+    } catch (Exiv2::Error& e) {
+        std::cerr << "Error: " << e.what() << std::endl;
     }
 
+  return d;
+}
+
+
+
+Texture ReloadTexture(Texture tin, int width, int height) {
+    GLuint tid = (GLuint)(uintptr_t)tin.texture;
+    glDeleteTextures((GLsizei)1, &tid);
+
     GLenum dataFormat = GL_RGBA;
     GLuint textureHandle;
     glGenTextures(1, &textureHandle);
@@ -78,19 +183,107 @@ Texture LoadTexture(const char * path)
     Texture t;
     t.texture = (void*)(uintptr_t)(textureHandle);
     t.size = ImVec2((float)width,(float)height);
+    t.exif = tin.exif;
+    t.channels = tin.channels;
+
+    return t;
+}
+
+void RotateImage(Texture t) {
+  int height = t.size.y;
+  int width = t.size.x;
+  int channels = t.channels;
+
+  const unsigned int sizeBuffer = width * height * channels; 
+  unsigned char *tempBuffer = new unsigned char[sizeBuffer];
+
+  int nidx = 0;
+  for (int x = 0; x < width; x++)
+  {
+    for (int y = height - 1; y >= 0; y--)
+    {
+      int idx = (x + y * width) * channels;
+      for (int i = 0; i < channels; i++)
+        tempBuffer[nidx + i] = image[idx + i];
+
+      nidx = nidx + 4;
+    }
+  }
+
+  memcpy(image, tempBuffer, sizeBuffer);
+  delete[] tempBuffer;
+}
+
+Texture LoadImage(const char * path) {
+    const int channelCount = 4;
+    int imageFileChannelCount;
+    int width, height;
+    image = (uint8_t *)stbi_load(path, &width, &height, &imageFileChannelCount, channelCount);
+    if (image == NULL) {
+        fprintf(stderr, "%s\nFailed to open %s\n", stbi_failure_reason(), path);
+        return {nullptr,{0,0}};
+    }
+    auto exif = printExifData(path);
+
+    Texture t;
+    t.size = ImVec2((float)width,(float)height);
+    t.channels = channelCount;
+    t.exif = exif;
+    return t;
+}
+
+Texture LoadTexture(Texture tin) {
+    GLenum dataFormat = GL_RGBA;
+    GLuint textureHandle;
+    glGenTextures(1, &textureHandle);
+    glBindTexture(GL_TEXTURE_2D, textureHandle);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tin.size.x, tin.size.y, 0, dataFormat, GL_UNSIGNED_BYTE, image);
+
+    Texture t = tin;
+    t.texture = (void*)(uintptr_t)(textureHandle);
+
+    if (t.exif.ImageOrientation == "3") {
+      RotateImage(t);
+      ReloadTexture(t, t.size.x, t.size.y);
+      t = ReloadTexture(t, t.size.y, t.size.x);
+      RotateImage(t);
+      t = ReloadTexture(t, t.size.y, t.size.x);
+    } else if (t.exif.ImageOrientation == "6") {
+      RotateImage(t);
+      t = ReloadTexture(t, t.size.y, t.size.x);
+    } else if (t.exif.ImageOrientation == "8") {
+      RotateImage(t);
+      t = ReloadTexture(t, t.size.y, t.size.x);
+      RotateImage(t);
+      t = ReloadTexture(t, t.size.y, t.size.x);
+      RotateImage(t);
+      t = ReloadTexture(t, t.size.y, t.size.x);
+    }
 
-    stbi_image_free(image);
     return t;
 }
 
 
-static bool init = true;
-static bool showHelp = false;
-static int mode = 0;
-const int maxAnnotatedTexels = 10000;
+
+const int MAX_ANNOATED_TEXELS = 10000;
 
 // Main code
 int main(int argc, char* argv[]) {
+  Texture t;
+
+  try {
+    auto args = argparse::parse<Args>(argc, argv, true);
+    t = LoadImage(args.fpath.c_str());
+    if (t.texture == nullptr) {
+      std::cerr << "failed load image" << std::endl;
+      return -1;
+    }
+  } catch (const std::runtime_error &e) {
+    std::cerr << "failed to parse arguments: " << e.what() << std::endl;
+    return -1;
+  }
   // Setup SDL
   if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_GAMECONTROLLER) !=
       0) {
@@ -99,8 +292,12 @@ int main(int argc, char* argv[]) {
   }
 
   bool TOOLTIP_ENABLED = false;
-  bool GRID_ENABLED = true;
+  bool GRID_ENABLED = false;
   bool AA_ENABLED = true;
+  bool SHOW_HELP = false;
+  bool SHOW_EXIF = false;
+  bool SHOW_HISTOGRAM = false;
+  int MODE = 0;
 
   // Decide GL+GLSL versions
 #if defined(IMGUI_IMPL_OPENGL_ES2)
@@ -140,9 +337,17 @@ int main(int argc, char* argv[]) {
   SDL_WindowFlags window_flags =
       (SDL_WindowFlags)(SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE |
                         SDL_WINDOW_ALLOW_HIGHDPI);
+
+
+  int wh = 800;
+  int ww = 1280;
+  if (t.size.y > t.size.x) {
+    ww = 500;
+    wh = 1280;
+  }
   SDL_Window *window =
       SDL_CreateWindow("tview", SDL_WINDOWPOS_CENTERED,
-                       SDL_WINDOWPOS_CENTERED, 1280, 720, window_flags);
+                       SDL_WINDOWPOS_CENTERED, ww, wh, window_flags);
   if (window == nullptr) {
     printf("Error: SDL_CreateWindow(): %s\n", SDL_GetError());
     return -1;
@@ -154,7 +359,6 @@ int main(int argc, char* argv[]) {
 
   // Setup Dear ImGui context
   IMGUI_CHECKVERSION();
-
   ImGui::CreateContext();
   ImGuiIO &io = ImGui::GetIO();
   (void)io;
@@ -163,34 +367,22 @@ int main(int argc, char* argv[]) {
   ImGuiTexInspect::ImplOpenGL3_Init(); // Or DirectX 11 equivalent (check your chosen backend header file)
   ImGuiTexInspect::Init();
   ImGuiTexInspect::CreateContext();
-
   ImGui::StyleColorsDark();
-
   ImGuiStyle &style = ImGui::GetStyle();
-
   ImGui_ImplSDL2_InitForOpenGL(window, gl_context);
   ImGui_ImplOpenGL3_Init(glsl_version);
 
   ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
+  auto flags = ImGuiTexInspect::InspectorFlags_FillVertical | ImGuiTexInspect::InspectorFlags_FillHorizontal;
 
-  Texture t;
-
-  if (init) {
-    init = false;
-    try {
-      auto args = argparse::parse<Args>(argc, argv, true);
-      t = LoadTexture(args.fpath.c_str());
-    } catch (const std::runtime_error &e) {
-      std::cerr << "failed to parse arguments: " << e.what() << std::endl;
-      return -1;
-    }
-  }
+  t = LoadTexture(t);
+  Histogram histogram = Histogram(t.size.x, t.size.y, t.channels);
+  histogram.Load(image);
 
   // Main loop
   bool done = false;
   while (!done)
   {
-    auto flags = ImGuiTexInspect::InspectorFlags_FillVertical | ImGuiTexInspect::InspectorFlags_FillHorizontal;
 
     // Poll and handle events (inputs, window resize, etc.)
     SDL_Event event;
@@ -217,14 +409,24 @@ int main(int argc, char* argv[]) {
               AA_ENABLED = !AA_ENABLED;
               break;
             case SDL_SCANCODE_H:
-              showHelp = !showHelp;
+              SHOW_HELP = !SHOW_HELP;
               break;
             case SDL_SCANCODE_D:
-              mode = (mode + 1) % 5;
+              MODE = (MODE + 1) % 5;
+              break;
+            case SDL_SCANCODE_R:
+              RotateImage(t);
+              t = ReloadTexture(t, t.size.y, t.size.x);
               break;
             case SDL_SCANCODE_Q:
               done = true;
               break;
+            case SDL_SCANCODE_E:
+              SHOW_EXIF = !SHOW_EXIF;
+              break;
+            case SDL_SCANCODE_C:
+              SHOW_HISTOGRAM = !SHOW_HISTOGRAM;
+              break;
             default:
               break;
         }
@@ -252,7 +454,7 @@ int main(int argc, char* argv[]) {
       ImGui::SetNextWindowPos(viewport->Pos);
       ImGui::SetNextWindowSize(viewport->Size);
       ImGui::Begin("Main", NULL,
-                   ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoResize);
+                   ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoBringToFrontOnFocus);
       auto wSize = ImGui::GetContentRegionAvail();
       if (t.texture != 0) {
 
@@ -286,18 +488,18 @@ int main(int argc, char* argv[]) {
             CurrentInspector_SetFlags(ImGuiTexInspect::InspectorFlags_NoForceFilterNearest);
         }
 
-        switch(mode) {
+        switch(MODE) {
           case 1:
-            ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::Arrow().UsePreset(ImGuiTexInspect::Arrow::NormalMap), maxAnnotatedTexels);
+            ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::Arrow().UsePreset(ImGuiTexInspect::Arrow::NormalMap), MAX_ANNOATED_TEXELS);
             break;
           case 2:
-            ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::ValueText(ImGuiTexInspect::ValueText::Format::HexString), maxAnnotatedTexels);
+            ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::ValueText(ImGuiTexInspect::ValueText::Format::HexString), MAX_ANNOATED_TEXELS);
             break;
           case 3:
-            ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::ValueText(ImGuiTexInspect::ValueText::Format::BytesDec), maxAnnotatedTexels);
+            ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::ValueText(ImGuiTexInspect::ValueText::Format::BytesDec), MAX_ANNOATED_TEXELS);
             break;
           case 4:
-            ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::ValueText(ImGuiTexInspect::ValueText::Format::Floats), maxAnnotatedTexels);
+            ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::ValueText(ImGuiTexInspect::ValueText::Format::Floats), MAX_ANNOATED_TEXELS);
             break;
           default:
             break;
@@ -310,25 +512,178 @@ int main(int argc, char* argv[]) {
       ImGui::PopStyleVar();
       ImGui::PopStyleVar();
 
-      if (showHelp){
+      if (SHOW_HELP){
         ImGui::OpenPopup("HelpPopup");
-        showHelp = !showHelp;
+        SHOW_HELP = !SHOW_HELP;
       }
+
       if (ImGui::BeginPopup("HelpPopup")) {
         ImGui::Text("tview Help");
         ImGui::Separator();
+        ImGui::Text("r - rotate 90 deg clockwise");
         ImGui::Text("g - toggle grid");
         ImGui::Text("a - toggle filtering");
         ImGui::Text("t - toggle tooltip");
         ImGui::Text("d - cycle pixel detail mode");
-        ImGui::Text("q - quit");
+        ImGui::Separator();
+        ImGui::Text("modes:");
+        ImGui::Text("\tOff");
+        ImGui::Text("\tGradient Arrow");
+        ImGui::Text("\tHex Code");
+        ImGui::Text("\tRGB Values");
+        ImGui::Text("\tFloat Values");
+        ImGui::Separator();
         ImGui::Text("h - show help popup");
+        ImGui::Text("c - toggle color histogram");
+        ImGui::Text("e - toggle EXIF info");
+        ImGui::Separator();
+        ImGui::Text("q - quit");
         ImGui::Separator();
         ImGui::Text("click anywhere to continue");
         ImGui::EndPopup();
       }
+      if (SHOW_EXIF && t.exif.CameraMake != "NULL") {
+        ImGuiWindowClass topmost;
+        topmost.ClassId = ImHashStr("TopMost");
+        topmost.ViewportFlagsOverrideSet = ImGuiViewportFlags_TopMost;
+        ImGui::SetNextWindowClass(&topmost);
+        ImGui::Begin("EXIF", NULL, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_AlwaysAutoResize  | ImGuiWindowFlags_NoFocusOnAppearing);
+        if(ImGui::BeginTable("Hardware", 2)) {
+          ImGui::TableNextRow();
+          ImGui::TableSetColumnIndex(0);
+          ImGui::Text("Make");
+          ImGui::TableSetColumnIndex(1);
+          ImGui::Text("%s", t.exif.CameraMake.c_str());
+
+          ImGui::TableNextRow();
+          ImGui::TableSetColumnIndex(0);
+          ImGui::Text("Model");
+          ImGui::TableSetColumnIndex(1);
+          ImGui::Text("%s", t.exif.CameraModel.c_str());
+
+          ImGui::TableNextRow();
+          ImGui::TableSetColumnIndex(0);
+          ImGui::Text("Lens");
+          ImGui::TableSetColumnIndex(1);
+          ImGui::Text("%s", t.exif.LensModel.c_str());
+
+          ImGui::EndTable();
+        }
+
+        ImGui::Separator();
+
+        if(ImGui::BeginTable("Photo", 2)) {
+          ImGui::TableNextRow();
+          ImGui::TableSetColumnIndex(0);
+          ImGui::Text("Shutter Speed");
+          ImGui::TableSetColumnIndex(1);
+          ImGui::Text("%s", t.exif.ShutterSpeed.c_str());
+
+          ImGui::TableNextRow();
+          ImGui::TableSetColumnIndex(0);
+          ImGui::Text("F-Stop");
+          ImGui::TableSetColumnIndex(1);
+          ImGui::Text("%s", t.exif.FNumber.c_str());
+
+          ImGui::TableNextRow();
+          ImGui::TableSetColumnIndex(0);
+          ImGui::Text("ISO");
+          ImGui::TableSetColumnIndex(1);
+          ImGui::Text("%s", t.exif.ISO.c_str());
+
+          ImGui::TableNextRow();
+          ImGui::TableSetColumnIndex(0);
+          ImGui::Text("Focal Length");
+          ImGui::TableSetColumnIndex(1);
+          ImGui::Text("%s", t.exif.FocalLength.c_str());
+
+          ImGui::TableNextRow();
+          ImGui::TableSetColumnIndex(0);
+          ImGui::Text("Exposure Comp");
+          ImGui::TableSetColumnIndex(1);
+          ImGui::Text("%s", t.exif.ExposureBias.c_str());
+
+          ImGui::TableNextRow();
+          ImGui::TableSetColumnIndex(0);
+          ImGui::Text("Metering Mode");
+          ImGui::TableSetColumnIndex(1);
+          ImGui::Text("%s", t.exif.MeteringMode.c_str());
+
+          ImGui::TableNextRow();
+          ImGui::TableSetColumnIndex(0);
+          ImGui::Text("Flash");
+          ImGui::TableSetColumnIndex(1);
+          ImGui::Text("%s", t.exif.Flash.c_str());
+
+          ImGui::EndTable();
+        }
+
+        ImGui::Separator();
+
+        if(ImGui::BeginTable("Meta", 2)) {
+          ImGui::TableNextRow();
+          ImGui::TableSetColumnIndex(0);
+          ImGui::Text("Date");
+          ImGui::TableSetColumnIndex(1);
+          ImGui::Text("%s %s", t.exif.TimeTaken.c_str(), t.exif.TimeTakenOffset.c_str());
+
+
+          ImGui::TableNextRow();
+          ImGui::TableSetColumnIndex(0);
+          ImGui::Text("Dimensions");
+          ImGui::TableSetColumnIndex(1);
+          ImGui::Text("%sx%s", t.exif.ImageDimensionX.c_str(), t.exif.ImageDimensiony.c_str());
+
+          ImGui::TableNextRow();
+          ImGui::TableSetColumnIndex(0);
+          ImGui::Text("Orientation");
+          ImGui::TableSetColumnIndex(1);
+          ImGui::Text("%s", t.exif.ImageOrientation.c_str());
+
+          ImGui::EndTable();
+        }
+
+        ImGui::Separator();
+
+        if(ImGui::BeginTable("Location", 2)) {
+          ImGui::TableNextRow();
+          ImGui::TableSetColumnIndex(0);
+          ImGui::Text("Latitude");
+          ImGui::TableSetColumnIndex(1);
+          ImGui::Text("%s %s", t.exif.GPSLat.c_str(), t.exif.GPSLatref.c_str());
+
+
+          ImGui::TableNextRow();
+          ImGui::TableSetColumnIndex(0);
+          ImGui::Text("Longitude");
+          ImGui::TableSetColumnIndex(1);
+          ImGui::Text("%s %s", t.exif.GPSLon.c_str(), t.exif.GPSLonref.c_str());
+
+          ImGui::EndTable();
+        }
+
+        ImGui::Separator();
+        ImGui::Text("Press e to hide");
+
+        ImGui::End();
+      }
+
+
+      if (SHOW_HISTOGRAM) {
+        ImGuiWindowClass topmost;
+        topmost.ClassId = ImHashStr("TopMost");
+        topmost.ViewportFlagsOverrideSet = ImGuiViewportFlags_TopMost;
+        ImGui::SetNextWindowClass(&topmost);
+        ImGui::Begin("Histogram", NULL, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_AlwaysAutoResize  | ImGuiWindowFlags_NoFocusOnAppearing);
+        histogram.Draw();
+        ImGui::Separator();
+        ImGui::Text("Press c to hide");
+
+        ImGui::End();
+      }
     }
 
+
     // Rendering
     ImGui::Render();
     glViewport(0, 0, (int)io.DisplaySize.x, (int)io.DisplaySize.y);
@@ -339,6 +694,10 @@ int main(int argc, char* argv[]) {
     SDL_GL_SwapWindow(window);
   }
 
+  if (image != nullptr) {
+    stbi_image_free(image);
+  }
+
   // Cleanup
   ImGui_ImplOpenGL3_Shutdown();
   ImGui_ImplSDL2_Shutdown();