viewer.cpp

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#include <iostream>
#include <cassert>

#include <qgl.h>

#include <jwsc/image/image.h>
#include <jwsc/imgblock/imgblock.h>
#include <jwsc/imgblock/imgblock_io.h>

#include <jwsc++/base/option.h>
#include <jwsc++/base/exception.h>

#include "viewer.h"

using namespace jwsc;


jwscxx::base::Options* opts = 0;


Viewer::Viewer(QWidget* parent, const char* name)
    : QWidget(parent, name)
{
    fnames = 0;

    QAction* new_viewer_action = new QAction("&New Viewer", CTRL+Key_N, this);
    QObject::connect(new_viewer_action, SIGNAL(activated()), this, 
            SLOT(new_viewer()));

    QAction* file_open_action = new QAction("&Open", CTRL+Key_O, this);
    QObject::connect(file_open_action, SIGNAL(activated()), this, 
            SLOT(file_open()));

    QAction* file_close_action = new QAction("&Close", CTRL+Key_L, this);
    QObject::connect(file_close_action, SIGNAL(activated()), this, 
            SLOT(file_close()));

    QAction* set_xz_view_action = new QAction("&XZ View", CTRL+Key_X, this);
    set_xz_view_action->setToggleAction(true);
    QObject::connect(set_xz_view_action, SIGNAL(toggled(bool)), this, 
            SLOT(set_xz_view(bool)));

    QAction* set_yz_view_action = new QAction("&YZ View", CTRL+Key_Y, this);
    set_yz_view_action->setToggleAction(true);
    QObject::connect(set_yz_view_action, SIGNAL(toggled(bool)), this, 
            SLOT(set_yz_view(bool)));

    QAction* set_draw_lines_action = new QAction("&Lines", CTRL+Key_I, this);
    set_draw_lines_action->setToggleAction(true);

    QPopupMenu* file = new QPopupMenu(this);
    new_viewer_action->addTo(file);
    file_open_action->addTo(file);
    file_close_action->addTo(file);

    QPopupMenu* view = new QPopupMenu(this);
    set_xz_view_action->addTo(view);
    set_yz_view_action->addTo(view);
    set_draw_lines_action->addTo(view);

    QMenuBar* m = new QMenuBar(this);
    m->insertItem("&File", file);
    m->insertItem("&View", view);

    QSplitter* xy_yz_splitter = new QSplitter(Qt::Horizontal, this);
    QSplitter* xy_xz_splitter = new QSplitter(Qt::Vertical, xy_yz_splitter);

    QWidget* xy_panel = new QWidget(xy_xz_splitter);
    QWidget* xz_panel = new QWidget(xy_xz_splitter);
    QWidget* yz_panel = new QWidget(xy_yz_splitter);

    /* XY Panel. */
    gl_xy_scroll_view = new QScrollView(xy_panel);
    gl_xy_scroll_view->setVScrollBarMode(QScrollView::AlwaysOn);

    xy_view = new GLImagePanelXY(gl_xy_scroll_view->viewport(), "xy_view");
    xy_view->updateGL();
    QObject::connect(xy_view, 
            SIGNAL(mouse_position_changed(int, int, int, const jwsc::Pixel_f*)), 
            this, SLOT(update_xy_line_edit(int, int, int, const jwsc::Pixel_f*)));
    QObject::connect(set_draw_lines_action, SIGNAL(toggled(bool)), xy_view, 
            SLOT(set_draw_line(bool)));

    gl_xy_scroll_view->addChild(xy_view);

    xy_line_edit = new QLineEdit(xy_panel);
    xy_line_edit->setReadOnly(TRUE);

    /* XZ Panel. */
    gl_xz_scroll_view = new QScrollView(xz_panel);
    gl_xz_scroll_view->setVScrollBarMode(QScrollView::AlwaysOn);

    xz_view = new GLImagePanelXZ(gl_xz_scroll_view->viewport(), "xz_view");
    xz_view->updateGL();
    QObject::connect(set_draw_lines_action, SIGNAL(toggled(bool)), xz_view, 
            SLOT(set_draw_line(bool)));

    gl_xz_scroll_view->addChild(xz_view);

    xz_line_edit = new QLineEdit(xz_panel);
    xz_line_edit->setReadOnly(TRUE);

    xy_fname_line_edit = new QLineEdit(xy_panel);
    xy_fname_line_edit->setReadOnly(TRUE);

    /* YZ Panel. */
    gl_yz_scroll_view = new QScrollView(yz_panel);
    gl_yz_scroll_view->setVScrollBarMode(QScrollView::AlwaysOn);

    yz_view = new GLImagePanelYZ(gl_yz_scroll_view->viewport(), "yz_view");
    yz_view->updateGL();
    QObject::connect(set_draw_lines_action, SIGNAL(toggled(bool)), yz_view, 
            SLOT(set_draw_line(bool)));

    gl_yz_scroll_view->addChild(yz_view);

    yz_line_edit = new QLineEdit(yz_panel);
    yz_line_edit->setReadOnly(TRUE);

    /* X-axis Selector. */
    x_axis_slider = new QSlider(xy_panel);
    x_axis_slider->setRange(0, 0);
    x_axis_slider->setOrientation(Qt::Horizontal);

    x_axis_spin_box = new QSpinBox(xy_panel);
    x_axis_spin_box->setRange(0, 0);

    /* Y-axis Selector. */
    y_axis_slider = new QSlider(xy_panel);
    y_axis_slider->setRange(0, 0);

    y_axis_spin_box = new QSpinBox(xy_panel);
    y_axis_spin_box->setRange(0, 0);

    /* Z-axis Selector. */
    xz_z_axis_slider = new QSlider(xz_panel);
    xz_z_axis_slider->setRange(0, 0);
    yz_z_axis_slider = new QSlider(yz_panel);
    yz_z_axis_slider->setRange(0, 0);
    yz_z_axis_slider->setOrientation(Qt::Horizontal);

    xz_z_axis_spin_box = new QSpinBox(xz_panel);
    xz_z_axis_spin_box->setRange(0, 0);
    yz_z_axis_spin_box = new QSpinBox(yz_panel);
    yz_z_axis_spin_box->setRange(0, 0);

    QObject::connect(xz_z_axis_slider, SIGNAL(valueChanged(int)), 
            this, SLOT(update_xy_fname_line_edit(int)));

    /* XY Layout. */
    QHBoxLayout* xy_slider_spin_box_layout = new QHBoxLayout();
    xy_slider_spin_box_layout->addWidget(x_axis_slider);
    xy_slider_spin_box_layout->addWidget(x_axis_spin_box);

    QHBoxLayout* xy_spin_box_line_edit_layout = new QHBoxLayout();
    xy_spin_box_line_edit_layout->addWidget(y_axis_spin_box);
    xy_spin_box_line_edit_layout->addWidget(xy_line_edit);

    QHBoxLayout* xy_fname_line_edit_layout = new QHBoxLayout();
    xy_fname_line_edit_layout->addWidget(xy_fname_line_edit);

    QGridLayout* xy_panel_layout = new QGridLayout(xy_panel, 4, 2, 10);
    xy_panel_layout->addLayout(xy_slider_spin_box_layout, 0, 1);
    xy_panel_layout->addWidget(y_axis_slider, 1, 0);
    xy_panel_layout->addWidget(gl_xy_scroll_view, 1, 1);
    xy_panel_layout->addMultiCellLayout(xy_spin_box_line_edit_layout, 
            2, 2, 0, 1);
    xy_panel_layout->addMultiCellLayout(xy_fname_line_edit_layout, 3, 3, 0, 1);

    /* XZ Layout. */
    QHBoxLayout* xz_spin_box_line_edit_layout = new QHBoxLayout();
    xz_spin_box_line_edit_layout->addWidget(xz_z_axis_spin_box);
    xz_spin_box_line_edit_layout->addWidget(xz_line_edit);

    QGridLayout* xz_panel_layout = new QGridLayout(xz_panel, 2, 2, 10);
    xz_panel_layout->addWidget(xz_z_axis_slider, 0, 0);
    xz_panel_layout->addWidget(gl_xz_scroll_view, 0, 1);
    xz_panel_layout->addMultiCellLayout(xz_spin_box_line_edit_layout, 
            1, 1, 0, 1);


    /* YZ Layout. */
    QHBoxLayout* yz_slider_spin_box_layout = new QHBoxLayout();
    yz_slider_spin_box_layout->addWidget(yz_z_axis_slider);
    yz_slider_spin_box_layout->addWidget(yz_z_axis_spin_box);

    QGridLayout* yz_panel_layout = new QGridLayout(yz_panel, 3, 1, 10);
    yz_panel_layout->addLayout(yz_slider_spin_box_layout, 0, 0);
    yz_panel_layout->addWidget(gl_yz_scroll_view, 1, 0);
    yz_panel_layout->addWidget(yz_line_edit, 2, 0);

    /* Application Layout. */
    QHBoxLayout* top_level_layout = new QHBoxLayout(this, 10);
    top_level_layout->setMenuBar(m);
    top_level_layout->addWidget(xy_yz_splitter);

    gl_xy_scroll_view->viewport()->setMaximumSize(xy_view->size());
    gl_xz_scroll_view->viewport()->setMaximumSize(xz_view->size());
    gl_yz_scroll_view->viewport()->setMaximumSize(yz_view->size());

    updating_gl_scroll_view = 0;
    mutex = new QMutex(TRUE);

    img_blk = NULL;

    /* By default, turn on the XZ and YZ views and lines. */
    set_xz_view_action->toggle();
    set_yz_view_action->toggle();
    set_draw_lines_action->toggle();
}

void Viewer::set_xz_view(bool on)
{
    int num_imgs, num_rows, num_cols;

    show_xz_view = on;

    if (img_blk == NULL)
    {
        num_imgs = num_rows = num_cols = 1;
    }
    else
    {
        num_imgs = img_blk->num_imgs;
        num_rows = img_blk->num_rows;
        num_cols = img_blk->num_cols;
    }

    xy_view->set_draw_x_line(on);

    if (show_xz_view)
    {
        xz_view->set_imgblock(img_blk);
        y_axis_slider->setRange(0, num_rows - 1);
        y_axis_slider->update();
        y_axis_spin_box->setRange(0, num_rows - 1);
        y_axis_spin_box->update();
        xz_z_axis_slider->setRange(0, num_imgs - 1);
        xz_z_axis_slider->update();
        xz_z_axis_spin_box->setRange(0, num_imgs - 1);
        xz_z_axis_spin_box->update();
        xz_view->updateGL();
        xy_view->updateGL();
        gl_xz_scroll_view->viewport()->setMaximumSize(xz_view->size());

        QObject::connect(gl_xy_scroll_view, SIGNAL(contentsMoving(int, int)),
                this, SLOT(update_gl_xz_scroll_view(int, int)));
        QObject::connect(gl_xz_scroll_view, SIGNAL(contentsMoving(int, int)),
                this, SLOT(update_gl_xy_scroll_view(int, int)));
        QObject::connect(xz_view, 
                SIGNAL(mouse_position_changed(int, int, int, const jwsc::Pixel_f*)),
                this, SLOT(update_xz_line_edit(int, int, int, const jwsc::Pixel_f*)));

        QObject::connect(y_axis_slider, SIGNAL(valueChanged(int)), 
                xy_view, SLOT(set_current_y_index(int)));
        QObject::connect(y_axis_slider, SIGNAL(valueChanged(int)), 
                xz_view, SLOT(set_current_y_index(int)));
        QObject::connect(y_axis_slider, SIGNAL(valueChanged(int)), 
                yz_view, SLOT(set_current_y_index(int)));
        QObject::connect(y_axis_slider, SIGNAL(valueChanged(int)), 
                y_axis_spin_box, SLOT(setValue(int)));
        QObject::connect(y_axis_spin_box, SIGNAL(valueChanged(int)), 
                y_axis_slider, SLOT(setValue(int)));

        QObject::connect(xz_z_axis_slider, SIGNAL(valueChanged(int)), 
                xy_view, SLOT(set_current_z_index(int)));
        QObject::connect(xz_z_axis_slider, SIGNAL(valueChanged(int)), 
                xz_view, SLOT(set_current_z_index(int)));
        QObject::connect(xz_z_axis_slider, SIGNAL(valueChanged(int)), 
                yz_view, SLOT(set_current_z_index(int)));

        QObject::connect(xz_z_axis_slider, SIGNAL(valueChanged(int)), 
                xz_z_axis_spin_box, SLOT(setValue(int)));
        QObject::connect(xz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                xz_z_axis_slider, SLOT(setValue(int)));

        if (show_yz_view)
        {
            QObject::connect(yz_z_axis_slider, SIGNAL(valueChanged(int)), 
                    xz_z_axis_slider, SLOT(setValue(int)));
            QObject::connect(yz_z_axis_slider, SIGNAL(valueChanged(int)), 
                    xz_z_axis_spin_box, SLOT(setValue(int)));
            QObject::connect(yz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                    xz_z_axis_slider, SLOT(setValue(int)));
            QObject::connect(yz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                    xz_z_axis_spin_box, SLOT(setValue(int)));
            QObject::connect(xz_z_axis_slider, SIGNAL(valueChanged(int)), 
                    yz_z_axis_slider, SLOT(setValue(int)));
            QObject::connect(xz_z_axis_slider, SIGNAL(valueChanged(int)), 
                    yz_z_axis_spin_box, SLOT(setValue(int)));
            QObject::connect(xz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                    yz_z_axis_slider, SLOT(setValue(int)));
            QObject::connect(xz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                    yz_z_axis_spin_box, SLOT(setValue(int)));
        }
    }
    else
    {
        xz_view->set_imgblock(NULL);
        xz_view->updateGL();
        xy_view->updateGL();
        gl_xz_scroll_view->viewport()->setMaximumSize(xz_view->size());
        y_axis_slider->setRange(0, 0);
        y_axis_spin_box->setRange(0, 0);
        xz_z_axis_slider->setRange(0, 0);
        xz_z_axis_spin_box->setRange(0, 0);
        y_axis_slider->update();
        y_axis_spin_box->update();
        xz_z_axis_slider->update();
        xz_z_axis_spin_box->update();

        QObject::disconnect(gl_xy_scroll_view, SIGNAL(contentsMoving(int, int)),
                this, SLOT(update_gl_xz_scroll_view(int, int)));
        QObject::disconnect(gl_xz_scroll_view, SIGNAL(contentsMoving(int, int)),
                this, SLOT(update_gl_xy_scroll_view(int, int)));
        QObject::disconnect(xz_view, 
                SIGNAL(mouse_position_changed(int, int, int, const jwsc::Pixel_f*)),
                this, SLOT(update_xz_line_edit(int, int, int, const jwsc::Pixel_f*)));

        QObject::disconnect(y_axis_slider, SIGNAL(valueChanged(int)), 
                xy_view, SLOT(set_current_y_index(int)));
        QObject::disconnect(y_axis_slider, SIGNAL(valueChanged(int)), 
                xz_view, SLOT(set_current_y_index(int)));
        QObject::disconnect(y_axis_slider, SIGNAL(valueChanged(int)), 
                yz_view, SLOT(set_current_y_index(int)));
        QObject::disconnect(y_axis_slider, SIGNAL(valueChanged(int)), 
                y_axis_spin_box, SLOT(setValue(int)));
        QObject::disconnect(y_axis_spin_box, SIGNAL(valueChanged(int)), 
                y_axis_slider, SLOT(setValue(int)));

        QObject::disconnect(xz_z_axis_slider, SIGNAL(valueChanged(int)), 
                xy_view, SLOT(set_current_z_index(int)));
        QObject::disconnect(xz_z_axis_slider, SIGNAL(valueChanged(int)), 
                xz_view, SLOT(set_current_z_index(int)));
        QObject::disconnect(xz_z_axis_slider, SIGNAL(valueChanged(int)), 
                yz_view, SLOT(set_current_z_index(int)));

        QObject::disconnect(xz_z_axis_slider, SIGNAL(valueChanged(int)), 
                xz_z_axis_spin_box, SLOT(setValue(int)));
        QObject::disconnect(xz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                xz_z_axis_slider, SLOT(setValue(int)));

        if (show_yz_view)
        {
            QObject::disconnect(yz_z_axis_slider, SIGNAL(valueChanged(int)), 
                    xz_z_axis_slider, SLOT(setValue(int)));
            QObject::disconnect(yz_z_axis_slider, SIGNAL(valueChanged(int)), 
                    xz_z_axis_spin_box, SLOT(setValue(int)));
            QObject::disconnect(yz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                    xz_z_axis_slider, SLOT(setValue(int)));
            QObject::disconnect(yz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                    xz_z_axis_spin_box, SLOT(setValue(int)));
            QObject::disconnect(xz_z_axis_slider, SIGNAL(valueChanged(int)), 
                    yz_z_axis_slider, SLOT(setValue(int)));
            QObject::disconnect(xz_z_axis_slider, SIGNAL(valueChanged(int)), 
                    yz_z_axis_spin_box, SLOT(setValue(int)));
            QObject::disconnect(xz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                    yz_z_axis_slider, SLOT(setValue(int)));
            QObject::disconnect(xz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                    yz_z_axis_spin_box, SLOT(setValue(int)));
        }
    }
}

void Viewer::set_yz_view(bool on)
{
    int num_imgs, num_rows, num_cols;

    show_yz_view = on;

    if (img_blk == NULL)
    {
        num_imgs = num_rows = num_cols = 1;
    }
    else
    {
        num_imgs = img_blk->num_imgs;
        num_rows = img_blk->num_rows;
        num_cols = img_blk->num_cols;
    }

    xy_view->set_draw_y_line(on);

    if (show_yz_view)
    {
        yz_view->set_imgblock(img_blk);
        x_axis_slider->setRange(0, num_cols - 1);
        x_axis_slider->update();
        x_axis_spin_box->setRange(0, num_cols - 1);
        x_axis_spin_box->update();
        yz_z_axis_slider->setRange(0, num_imgs - 1);
        yz_z_axis_slider->update();
        yz_z_axis_spin_box->setRange(0, num_imgs - 1);
        yz_z_axis_spin_box->update();
        yz_view->updateGL();
        xy_view->updateGL();
        gl_yz_scroll_view->viewport()->setMaximumSize(yz_view->size());

        QObject::connect(gl_yz_scroll_view, SIGNAL(contentsMoving(int, int)),
                this, SLOT(update_gl_xy_scroll_view(int, int)));
        QObject::connect(yz_view, 
                SIGNAL(mouse_position_changed(int, int, int, const jwsc::Pixel_f*)),
                this, SLOT(update_yz_line_edit(int, int, int, const jwsc::Pixel_f*)));

        QObject::connect(x_axis_slider, SIGNAL(valueChanged(int)), 
                xy_view, SLOT(set_current_x_index(int)));
        QObject::connect(x_axis_slider, SIGNAL(valueChanged(int)), 
                xz_view, SLOT(set_current_x_index(int)));
        QObject::connect(x_axis_slider, SIGNAL(valueChanged(int)), 
                yz_view, SLOT(set_current_x_index(int)));
        QObject::connect(x_axis_slider, SIGNAL(valueChanged(int)), 
                x_axis_spin_box, SLOT(setValue(int)));
        QObject::connect(x_axis_spin_box, SIGNAL(valueChanged(int)), 
                x_axis_slider, SLOT(setValue(int)));

        QObject::connect(yz_z_axis_slider, SIGNAL(valueChanged(int)), 
                xy_view, SLOT(set_current_z_index(int)));
        QObject::connect(yz_z_axis_slider, SIGNAL(valueChanged(int)), 
                xz_view, SLOT(set_current_z_index(int)));
        QObject::connect(yz_z_axis_slider, SIGNAL(valueChanged(int)), 
                yz_view, SLOT(set_current_z_index(int)));

        QObject::connect(yz_z_axis_slider, SIGNAL(valueChanged(int)), 
                yz_z_axis_spin_box, SLOT(setValue(int)));
        QObject::connect(yz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                yz_z_axis_slider, SLOT(setValue(int)));

        if (show_xz_view)
        {
            QObject::connect(yz_z_axis_slider, SIGNAL(valueChanged(int)), 
                    xz_z_axis_slider, SLOT(setValue(int)));
            QObject::connect(yz_z_axis_slider, SIGNAL(valueChanged(int)), 
                    xz_z_axis_spin_box, SLOT(setValue(int)));
            QObject::connect(yz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                    xz_z_axis_slider, SLOT(setValue(int)));
            QObject::connect(yz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                    xz_z_axis_spin_box, SLOT(setValue(int)));
            QObject::connect(xz_z_axis_slider, SIGNAL(valueChanged(int)), 
                    yz_z_axis_slider, SLOT(setValue(int)));
            QObject::connect(xz_z_axis_slider, SIGNAL(valueChanged(int)), 
                    yz_z_axis_spin_box, SLOT(setValue(int)));
            QObject::connect(xz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                    yz_z_axis_slider, SLOT(setValue(int)));
            QObject::connect(xz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                    yz_z_axis_spin_box, SLOT(setValue(int)));
        }
    }
    else
    {
        yz_view->set_imgblock(NULL);
        yz_view->updateGL();
        xy_view->updateGL();
        gl_yz_scroll_view->viewport()->setMaximumSize(yz_view->size());
        x_axis_slider->setRange(0, 0);
        x_axis_spin_box->setRange(0, 0);
        yz_z_axis_slider->setRange(0, 0);
        yz_z_axis_spin_box->setRange(0, 0);
        x_axis_slider->update();
        x_axis_spin_box->update();
        yz_z_axis_slider->update();
        yz_z_axis_spin_box->update();

        QObject::disconnect(gl_yz_scroll_view, SIGNAL(contentsMoving(int, int)),
                this, SLOT(update_gl_xy_scroll_view(int, int)));
        QObject::disconnect(yz_view, 
                SIGNAL(mouse_position_changed(int, int, int, const jwsc::Pixel_f*)),
                this, SLOT(update_yz_line_edit(int, int, int, const jwsc::Pixel_f*)));

        QObject::disconnect(x_axis_slider, SIGNAL(valueChanged(int)), 
                xy_view, SLOT(set_current_x_index(int)));
        QObject::disconnect(x_axis_slider, SIGNAL(valueChanged(int)), 
                xz_view, SLOT(set_current_x_index(int)));
        QObject::disconnect(x_axis_slider, SIGNAL(valueChanged(int)), 
                yz_view, SLOT(set_current_x_index(int)));
        QObject::disconnect(x_axis_slider, SIGNAL(valueChanged(int)), 
                x_axis_spin_box, SLOT(setValue(int)));
        QObject::disconnect(x_axis_spin_box, SIGNAL(valueChanged(int)), 
                x_axis_slider, SLOT(setValue(int)));

        QObject::disconnect(yz_z_axis_slider, SIGNAL(valueChanged(int)), 
                xy_view, SLOT(set_current_z_index(int)));
        QObject::disconnect(yz_z_axis_slider, SIGNAL(valueChanged(int)), 
                xz_view, SLOT(set_current_z_index(int)));
        QObject::disconnect(yz_z_axis_slider, SIGNAL(valueChanged(int)), 
                yz_view, SLOT(set_current_z_index(int)));

        QObject::disconnect(yz_z_axis_slider, SIGNAL(valueChanged(int)), 
                yz_z_axis_spin_box, SLOT(setValue(int)));
        QObject::disconnect(yz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                yz_z_axis_slider, SLOT(setValue(int)));

        if (show_xz_view)
        {
            QObject::disconnect(yz_z_axis_slider, SIGNAL(valueChanged(int)), 
                    xz_z_axis_slider, SLOT(setValue(int)));
            QObject::disconnect(yz_z_axis_slider, SIGNAL(valueChanged(int)), 
                    xz_z_axis_spin_box, SLOT(setValue(int)));
            QObject::disconnect(yz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                    xz_z_axis_slider, SLOT(setValue(int)));
            QObject::disconnect(yz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                    xz_z_axis_spin_box, SLOT(setValue(int)));
            QObject::disconnect(xz_z_axis_slider, SIGNAL(valueChanged(int)), 
                    yz_z_axis_slider, SLOT(setValue(int)));
            QObject::disconnect(xz_z_axis_slider, SIGNAL(valueChanged(int)), 
                    yz_z_axis_spin_box, SLOT(setValue(int)));
            QObject::disconnect(xz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                    yz_z_axis_slider, SLOT(setValue(int)));
            QObject::disconnect(xz_z_axis_spin_box, SIGNAL(valueChanged(int)), 
                    yz_z_axis_spin_box, SLOT(setValue(int)));
        }
    }
}

void Viewer::file_close()
{
    if (img_blk != NULL)
    {
        int num_imgs = img_blk->num_imgs;

        for (int i = 0; i < num_imgs; i++)
        {
            free(fnames[ i ]);
        }
        free(fnames);
        fnames = 0;

        free_imgblock_f(img_blk);
        img_blk = NULL;
    }

    xy_view->set_imgblock(NULL);
    xz_view->set_imgblock(NULL);
    yz_view->set_imgblock(NULL);

    xy_view->updateGL();
    xz_view->updateGL();
    yz_view->updateGL();

    gl_xy_scroll_view->viewport()->setMaximumSize(xy_view->size());
    gl_xz_scroll_view->viewport()->setMaximumSize(xz_view->size());
    gl_yz_scroll_view->viewport()->setMaximumSize(yz_view->size());

    x_axis_slider->setRange(0, 0);
    x_axis_spin_box->setRange(0, 0);
    y_axis_slider->setRange(0, 0);
    y_axis_spin_box->setRange(0, 0);
    xz_z_axis_slider->setRange(0, 0);
    xz_z_axis_spin_box->setRange(0, 0);
    yz_z_axis_slider->setRange(0, 0);
    yz_z_axis_spin_box->setRange(0, 0);

    x_axis_slider->update();
    x_axis_spin_box->update();
    y_axis_slider->update();
    y_axis_spin_box->update();
    xz_z_axis_slider->update();
    xz_z_axis_spin_box->update();
    yz_z_axis_slider->update();
    yz_z_axis_spin_box->update();
}

void Viewer::file_open()
{
    int num_rows, num_cols, num_imgs;
    int img;
    Error* err;

    QStringList image_names = QFileDialog::getOpenFileNames(
            "Images (*.tif *.tiff *.jpeg *.jpg *.png *.jiff)", 
            QDir::currentDirPath(), this);

    if (image_names.empty())
    {
        return;
    }

    file_close();

    image_names.sort();
    num_imgs = image_names.count();

    assert(fnames = (char**)malloc(num_imgs*sizeof(char*)));
    for (img = 0; img < num_imgs; img++)
    {
        int len = image_names[ img ].length() + 1;
        assert(fnames[ img ] = (char*)malloc(len*sizeof(char)));
        strcpy(fnames[ img ], image_names[ img ].ascii());
    }

    if ((err = read_imgblock_named_f(&img_blk, (const char**)fnames, num_imgs)) 
            != NULL)
    {
        print_error_msg_exit("viewer", err->msg);
    }

    //free(fnames);

    num_rows = img_blk->num_rows;
    num_cols = img_blk->num_cols;

    xy_view->set_imgblock(img_blk);
    xz_view->set_imgblock(img_blk);
    yz_view->set_imgblock(img_blk);

    x_axis_slider->setRange(0, num_cols - 1);
    x_axis_slider->update();
    x_axis_spin_box->setRange(0, num_cols - 1);
    x_axis_spin_box->update();
    y_axis_slider->setRange(0, num_rows - 1);
    y_axis_slider->update();
    y_axis_spin_box->setRange(0, num_rows - 1);
    y_axis_spin_box->update();
    xz_z_axis_slider->setRange(0, num_imgs - 1);
    xz_z_axis_slider->update();
    yz_z_axis_slider->setRange(0, num_imgs - 1);
    yz_z_axis_slider->update();
    xz_z_axis_spin_box->setRange(0, num_imgs - 1);
    xz_z_axis_spin_box->update();
    yz_z_axis_spin_box->setRange(0, num_imgs - 1);
    yz_z_axis_spin_box->update();

    xy_view->updateGL();
    xz_view->updateGL();
    yz_view->updateGL();

    gl_xy_scroll_view->viewport()->setMaximumSize(xy_view->size());
    gl_xz_scroll_view->viewport()->setMaximumSize(xz_view->size());
    gl_yz_scroll_view->viewport()->setMaximumSize(yz_view->size());

    update_xy_fname_line_edit(0);
}

void Viewer::new_viewer()
{
    Viewer* theViewer = new Viewer();
    theViewer->show();
}

void Viewer::update_gl_xy_scroll_view(int x, int y)
{
    mutex->lock();

    if (!updating_gl_scroll_view )
    {
        updating_gl_scroll_view = 1;
        gl_xy_scroll_view->setContentsPos(x, gl_xy_scroll_view->contentsY());
    }
    else
    {
        updating_gl_scroll_view = 0;
    }

    mutex->unlock();
}

void Viewer::update_gl_xz_scroll_view(int x, int y)
{
    mutex->lock();

    if (!updating_gl_scroll_view )
    {
        updating_gl_scroll_view = 1;
        gl_xz_scroll_view->setContentsPos(x, gl_xz_scroll_view->contentsY());
    }
    else
    {
        updating_gl_scroll_view = 0;
    }

    mutex->unlock();
}

void Viewer::update_gl_yz_scroll_view(int x, int y)
{
    mutex->lock();

    if (!updating_gl_scroll_view )
    {
        updating_gl_scroll_view = 1;
        gl_yz_scroll_view->setContentsPos(x, gl_yz_scroll_view->contentsY());
    }
    else
    {
        updating_gl_scroll_view = 0;
    }

    mutex->unlock();
}

void Viewer::update_xy_line_edit(int x, int y, int z, const Pixel_f* px)
{
    QString string;
    
    string.sprintf("%3d  %3d  %3d", (int)(255*px->r), (int)(255*px->g), 
            (int)(255*px->b));
    xy_line_edit->setText(string);
}

void Viewer::update_xz_line_edit(int x, int y, int z, const Pixel_f* px)
{
    QString string;
    
    string.sprintf("%3d  %3d  %3d", (int)(255*px->r), (int)(255*px->g), 
            (int)(255*px->b));
    xz_line_edit->setText(string);
}

void Viewer::update_yz_line_edit(int x, int y, int z, const Pixel_f* px)
{
    QString string;
    
    string.sprintf("%3d  %3d  %3d", (int)(255*px->r), (int)(255*px->g), 
            (int)(255*px->b));
    yz_line_edit->setText(string);
}

void Viewer::update_xy_fname_line_edit(int i)
{
    if (!fnames)
    {
        xy_fname_line_edit->setText("");
        return;
    }

    const char* str = fnames[ i ];
    int len = strlen(str);
    const char* ptr = &(str[ len-1 ]);

    while (ptr != str && *ptr != '/')
        ptr--;

    if (*ptr == '/')
        ptr++;

    //std::cerr << ptr << '\n';
    //QString string(ptr);
    xy_fname_line_edit->setText(ptr);
}


void clean_up()
{
    delete opts;
}


void print_usage(void)
{
    cerr << "usage: viewer OPTIONS\n";
    cerr << "where OPTIONS is one or more of the following:\n";
    opts->print();
}


void process_help_opt(void)
{   
    print_usage();
    clean_up();
    exit(EXIT_SUCCESS);
}


void process_version_opt(void)
{
    std::cout << VIEWER_PACKAGE_STRING << "\n";
    clean_up();
    exit(EXIT_SUCCESS);
}

int main(int argc, char **argv)
{
    using jwscxx::base::Option_no_arg;
    using jwscxx::base::Option_with_arg;
    using jwscxx::base::Arg_error;
    using jwscxx::base::Options;

    int rstatus = EXIT_SUCCESS;

    const char* l_name;
    const char* desc;

    opts = new Options();

    l_name = "help";
    desc   = "Program usage";
    opts->add(new Option_no_arg('h', l_name, desc, process_help_opt));

    l_name = "version";
    desc   = "Program version.";
    opts->add(new Option_no_arg('v', l_name, desc, process_version_opt));

    try
    {
        opts->process(argc, argv);

        QApplication app(argc, argv);

        if (! QGLFormat::hasOpenGL())
        {
            throw Arg_error("This system has no OpenGL support");
        }

        Viewer theViewer;
        theViewer.show();

        QObject::connect(&app, SIGNAL(lastWindowClosed()), &app, SLOT(quit()));

        rstatus = app.exec();
    }
    catch (Arg_error e)
    {
        cerr << "viewer: ";
        e.print();
        rstatus = EXIT_FAILURE;
    }

    clean_up();

    return rstatus;
}