Micro ct (#40)

ADD: This branch is for InVesalius to read BMP, TIF, JPEG and PNG files.

Micro ct (#40)
ADD: This branch is for InVesalius to read BMP, TIF, JPEG and PNG files.
Paulo Henrique Junqueira Amorim · GitHub
1 parent 335b3a7c
Showing 10 changed files with 2268 additions and 11 deletions Show diff stats
invesalius/constants.py
invesalius/control.py
invesalius/data/imagedata_utils.py
invesalius/gui/bitmap_preview_panel.py
invesalius/gui/dialogs.py
invesalius/gui/frame.py
invesalius/gui/import_bitmap_panel.py
invesalius/gui/task_slice.py
invesalius/presets.py
invesalius/reader/bitmap_reader.py
@@ -452,7 +452,7 @@ VTK_WARNING = 0
 [ID_DICOM_IMPORT, ID_PROJECT_OPEN, ID_PROJECT_SAVE_AS, ID_PROJECT_SAVE,
 ID_PROJECT_CLOSE, ID_PROJECT_INFO, ID_SAVE_SCREENSHOT, ID_DICOM_LOAD_NET,
 ID_PRINT_SCREENSHOT, ID_IMPORT_OTHERS_FILES, ID_ANALYZE_IMPORT, ID_PREFERENCES,
-ID_DICOM_NETWORK] = [wx.NewId() for number in range(13)]
+ID_DICOM_NETWORK, ID_TIFF_JPG_PNG] = [wx.NewId() for number in range(14)]
 ID_EXIT = wx.ID_EXIT
 ID_ABOUT = wx.ID_ABOUT
@@ -35,8 +35,10 @@ import project as prj
 import reader.analyze_reader as analyze
 import reader.dicom_grouper as dg
 import reader.dicom_reader as dcm
+import reader.bitmap_reader as bmp
 import session as ses
+
 import utils 
 import gui.dialogs as dialogs
 import subprocess
@@ -74,13 +76,20 @@ class Controller():
                                  'Save raycasting preset')
         Publisher.subscribe(self.OnOpenDicomGroup,
                                  'Open DICOM group')
+        Publisher.subscribe(self.OnOpenBitmapFiles,
+                                'Open bitmap files')
         Publisher.subscribe(self.Progress, "Update dicom load")
+        Publisher.subscribe(self.Progress, "Update bitmap load")
         Publisher.subscribe(self.OnLoadImportPanel, "End dicom load")
+        Publisher.subscribe(self.OnLoadImportBitmapPanel, "End bitmap load")
         Publisher.subscribe(self.OnCancelImport, 'Cancel DICOM load')
+        Publisher.subscribe(self.OnCancelImportBitmap, 'Cancel bitmap load')
+
         Publisher.subscribe(self.OnShowDialogCloseProject, 'Close Project')
         Publisher.subscribe(self.OnOpenProject, 'Open project')
         Publisher.subscribe(self.OnOpenRecentProject, 'Open recent project')
         Publisher.subscribe(self.OnShowAnalyzeFile, 'Show analyze dialog')
+        Publisher.subscribe(self.OnShowBitmapFile, 'Show bitmap dialog')
         Publisher.subscribe(self.ShowBooleanOpDialog, 'Show boolean dialog')
@@ -92,7 +101,9 @@ class Controller():
         Publisher.sendMessage('Hide import panel')
-
+    def OnCancelImportBitmap(self, pubsub_evt):
+        #self.cancel_import = True
+        Publisher.sendMessage('Hide import bitmap panel')
 ###########################
 ###########################
@@ -119,9 +130,35 @@ class Controller():
         self.LoadProject()
         Publisher.sendMessage("Enable state project", True)
-
+    def OnShowBitmapFile(self, pubsub_evt):
+        self.ShowDialogImportBitmapFile()
 ###########################
+    def ShowDialogImportBitmapFile(self):
+        # Offer to save current project if necessary
+        session = ses.Session()
+        st = session.project_status
+        if (st == const.PROJ_NEW) or (st == const.PROJ_CHANGE):
+            filename = session.project_path[1]
+            answer = dialog.SaveChangesDialog2(filename)
+            if answer:
+                self.ShowDialogSaveProject()
+            self.CloseProject()
+            #Publisher.sendMessage("Enable state project", False)
+            Publisher.sendMessage('Set project name')
+            Publisher.sendMessage("Stop Config Recording")
+            Publisher.sendMessage("Set slice interaction style", const.STATE_DEFAULT)
+
+        # Import TIFF, BMP, JPEG or PNG
+        dirpath = dialog.ShowImportBitmapDirDialog()
+
+        if dirpath and not os.listdir(dirpath):
+            dialog.ImportEmptyDirectory(dirpath)
+        elif dirpath:
+            self.StartImportBitmapPanel(dirpath)
+        #    Publisher.sendMessage("Load data to import panel", dirpath)
+
+
     def ShowDialogImportDirectory(self):
         # Offer to save current project if necessary
         session = ses.Session()
@@ -291,6 +328,12 @@ class Controller():
 ###########################
+    def StartImportBitmapPanel(self, path):
+        # retrieve DICOM files splited into groups
+        reader = bmp.ProgressBitmapReader()
+        reader.SetWindowEvent(self.frame)
+        reader.SetDirectoryPath(path)
+        Publisher.sendMessage('End busy cursor')
     def StartImportPanel(self, path):
@@ -324,6 +367,26 @@ class Controller():
             Publisher.sendMessage('Show import panel')
             Publisher.sendMessage("Show import panel in frame")
+    def OnLoadImportBitmapPanel(self, evt):
+        data = evt.data
+        ok = self.LoadImportBitmapPanel(data)
+        if ok:
+            Publisher.sendMessage('Show import bitmap panel in frame')
+            #Publisher.sendMessage("Show import panel in frame")
+
+    def LoadImportBitmapPanel(self, data):
+        #if patient_series and isinstance(patient_series, list):
+            #Publisher.sendMessage("Load import panel", patient_series)
+            #first_patient = patient_series[0]
+            #Publisher.sendMessage("Load bitmap preview", first_patient)
+        if  data:
+            Publisher.sendMessage("Load import bitmap panel", data)
+
+            return True
+        else:
+            dialog.ImportInvalidFiles()
+        return False
+
     def LoadImportPanel(self, patient_series):
         if patient_series and isinstance(patient_series, list):
@@ -335,6 +398,9 @@ class Controller():
             dialog.ImportInvalidFiles()
         return False
+
+    #----------- to import by command line ---------------------------------------------------
+
     def OnImportMedicalImages(self, pubsub_evt):
         directory = pubsub_evt.data
         self.ImportMedicalImages(directory)
@@ -358,6 +424,8 @@ class Controller():
         self.LoadProject()
         Publisher.sendMessage("Enable state project", True)
+    #-------------------------------------------------------------------------------------
+
     def LoadProject(self):
         proj = prj.Project()
@@ -401,9 +469,13 @@ class Controller():
             Publisher.sendMessage('Show mask', (mask_index, True))
         else:
             mask_name = const.MASK_NAME_PATTERN % (1,)
-            thresh = const.THRESHOLD_RANGE
-            colour = const.MASK_COLOUR[0]
+            if proj.modality != "UNKNOWN":
+                thresh = const.THRESHOLD_RANGE
+            else:
+                thresh = proj.threshold_range
+
+            colour = const.MASK_COLOUR[0]
             Publisher.sendMessage('Create new mask',
                                        (mask_name, thresh, colour))
@@ -483,6 +555,138 @@ class Controller():
         dirpath = session.CreateProject(filename)
         #proj.SavePlistProject(dirpath, filename)
+
+    def CreateBitmapProject(self, bmp_data, rec_data, matrix, matrix_filename):
+        name_to_const = {"AXIAL":const.AXIAL,
+                         "CORONAL":const.CORONAL,
+                         "SAGITTAL":const.SAGITAL}
+
+        name = rec_data[0]
+        orientation = rec_data[1]
+        sp_x = float(rec_data[2])
+        sp_y = float(rec_data[3])
+        sp_z = float(rec_data[4])
+        interval = int(rec_data[5])
+        
+        bits = bmp_data.GetFirstPixelSize()
+        sx, sy = size =  bmp_data.GetFirstBitmapSize()
+        
+        proj = prj.Project()
+        proj.name = name
+        proj.modality = 'UNKNOWN'
+        proj.SetAcquisitionModality(proj.modality)
+        proj.matrix_shape = matrix.shape
+        proj.matrix_dtype = matrix.dtype.name
+        proj.matrix_filename = matrix_filename
+        #proj.imagedata = imagedata
+        #proj.dicom_sample = dicom
+        proj.original_orientation =\
+                    name_to_const[orientation.upper()]
+        proj.window = float(matrix.max())
+        proj.level = float(matrix.max()/2)
+        
+        proj.threshold_range = int(matrix.min()), int(matrix.max())
+        #const.THRESHOLD_RANGE = proj.threshold_range
+
+        proj.spacing = self.Slice.spacing
+
+        ######
+        session = ses.Session()
+        filename = proj.name+".inv3"
+
+        filename = filename.replace("/", "") #Fix problem case other/Skull_DICOM
+
+        dirpath = session.CreateProject(filename)
+
+    def OnOpenBitmapFiles(self, pubsub_evt):
+        rec_data = pubsub_evt.data
+        bmp_data = bmp.BitmapData()
+        matrix, matrix_filename = self.OpenBitmapFiles(bmp_data, rec_data)
+        
+        self.CreateBitmapProject(bmp_data, rec_data, matrix, matrix_filename)
+
+        self.LoadProject()
+        Publisher.sendMessage("Enable state project", True)
+
+
+    def OpenBitmapFiles(self, bmp_data, rec_data):
+
+        if bmp_data.IsAllBitmapSameSize():
+
+            name = rec_data[0]
+            orientation = rec_data[1]
+            sp_x = float(rec_data[2])
+            sp_y = float(rec_data[3])
+            sp_z = float(rec_data[4])
+            interval = int(rec_data[5])
+         
+            interval += 1
+            
+            filelist = bmp_data.GetOnlyBitmapPath()[::interval]
+            bits = bmp_data.GetFirstPixelSize()
+
+            sx, sy = size =  bmp_data.GetFirstBitmapSize()
+            n_slices = len(filelist)
+            resolution_percentage = utils.calculate_resizing_tofitmemory(int(sx), int(sy), n_slices, bits/8)
+            
+            zspacing = sp_z * interval
+            xyspacing = (sp_y, sp_x)
+
+            if resolution_percentage < 1.0:
+
+                re_dialog = dialog.ResizeImageDialog()
+                re_dialog.SetValue(int(resolution_percentage*100))
+                re_dialog_value = re_dialog.ShowModal()
+                re_dialog.Close() 
+                
+                if re_dialog_value == wx.ID_OK:
+                    percentage = re_dialog.GetValue()
+                    resolution_percentage = percentage / 100.0
+                else:
+                    return
+
+                xyspacing = xyspacing[0] / resolution_percentage, xyspacing[1] / resolution_percentage
+ 
+
+            
+            self.matrix, scalar_range, self.filename = image_utils.bitmap2memmap(filelist, size,
+                                                                    orientation, (sp_z, sp_y, sp_x),resolution_percentage)
+
+
+            self.Slice = sl.Slice()
+            self.Slice.matrix = self.matrix
+            self.Slice.matrix_filename = self.filename
+
+            if orientation == 'AXIAL':
+                self.Slice.spacing = xyspacing[0], xyspacing[1], zspacing
+            elif orientation == 'CORONAL':
+                self.Slice.spacing = xyspacing[0], zspacing, xyspacing[1]
+            elif orientation == 'SAGITTAL':
+                self.Slice.spacing = zspacing, xyspacing[1], xyspacing[0]
+            
+            # 1(a): Fix gantry tilt, if any
+            #tilt_value = dicom.acquisition.tilt
+            #if (tilt_value) and (gui):
+            #    # Tell user gantry tilt and fix, according to answer
+            #    message = _("Fix gantry tilt applying the degrees below")
+            #    value = -1*tilt_value
+            #    tilt_value = dialog.ShowNumberDialog(message, value)
+            #    image_utils.FixGantryTilt(self.matrix, self.Slice.spacing, tilt_value)
+            #elif (tilt_value) and not (gui):
+            #    tilt_value = -1*tilt_value
+            #    image_utils.FixGantryTilt(self.matrix, self.Slice.spacing, tilt_value)
+
+            self.Slice.window_level = float(self.matrix.max()/2)
+            self.Slice.window_width = float(self.matrix.max())
+
+            scalar_range = int(self.matrix.min()), int(self.matrix.max())
+            Publisher.sendMessage('Update threshold limits list', scalar_range)
+
+            return self.matrix, self.filename#, dicom
+
+        else:
+            print "Error: All slices must be of the same size."
+
     def OnOpenDicomGroup(self, pubsub_evt):
         group, interval, file_range = pubsub_evt.data
         matrix, matrix_filename, dicom = self.OpenDicomGroup(group, interval, file_range, gui=True)
@@ -32,7 +32,9 @@ from vtk.util import numpy_support
 import constants as const
 from data import vtk_utils
+from reader import bitmap_reader
 import utils
+import converters
 # TODO: Test cases which are originally in sagittal/coronal orientation
 # and have gantry
@@ -416,6 +418,90 @@ class ImageCreator:
         return imagedata
+def bitmap2memmap(files, slice_size, orientation, spacing, resolution_percentage):
+    """
+    From a list of dicom files it creates memmap file in the temp folder and
+    returns it and its related filename.
+    """
+    message = _("Generating multiplanar visualization...")
+    update_progress= vtk_utils.ShowProgress(len(files) - 1, dialog_type = "ProgressDialog")
+
+    temp_file = tempfile.mktemp()
+
+    if orientation == 'SAGITTAL':
+        if resolution_percentage == 1.0:
+            shape = slice_size[0], slice_size[1], len(files)
+        else:
+            shape = math.ceil(slice_size[0]*resolution_percentage),\
+                    math.ceil(slice_size[1]*resolution_percentage), len(files)
+
+    elif orientation == 'CORONAL':
+        if resolution_percentage == 1.0:
+            shape = slice_size[1], len(files), slice_size[0]
+        else:
+            shape = math.ceil(slice_size[1]*resolution_percentage), len(files),\
+                                        math.ceil(slice_size[0]*resolution_percentage)
+    else:
+        if resolution_percentage == 1.0:
+            shape = len(files), slice_size[1], slice_size[0]
+        else:
+            shape = len(files), math.ceil(slice_size[1]*resolution_percentage),\
+                                        math.ceil(slice_size[0]*resolution_percentage)
+
+    matrix = numpy.memmap(temp_file, mode='w+', dtype='int16', shape=shape)
+    cont = 0
+    max_scalar = None
+    min_scalar = None
+    
+    for n, f in enumerate(files):
+        image_as_array = bitmap_reader.ReadBitmap(f)
+
+        image = converters.to_vtk(image_as_array, spacing=spacing,\
+                                    slice_number=1, orientation=orientation.upper())
+
+        if resolution_percentage != 1.0:
+            
+
+            image_resized = ResampleImage2D(image, px=None, py=None,\
+                                resolution_percentage = resolution_percentage, update_progress = None)
+
+            image = image_resized
+
+        min_aux, max_aux = image.GetScalarRange()
+        if min_scalar is None or min_aux < min_scalar:
+            min_scalar = min_aux
+
+        if max_scalar is None or max_aux > max_scalar:
+            max_scalar = max_aux
+
+        array = numpy_support.vtk_to_numpy(image.GetPointData().GetScalars())
+        array = array.astype("int16")
+
+        array = image_as_array
+
+        if orientation == 'CORONAL':
+            array.shape = matrix.shape[0], matrix.shape[2]
+            matrix[:, n, :] = array
+        elif orientation == 'SAGITTAL':
+            array.shape = matrix.shape[0], matrix.shape[1]
+            # TODO: Verify if it's necessary to add the slices swapped only in
+            # sagittal rmi or only in # Rasiane's case or is necessary in all
+            # sagittal cases.
+            matrix[:, :, n] = array
+        else:
+            print array.shape, matrix.shape
+            array.shape = matrix.shape[1], matrix.shape[2]
+            matrix[n] = array
+        update_progress(cont,message)
+        cont += 1
+
+    matrix.flush()
+    scalar_range = min_scalar, max_scalar
+
+    return matrix, scalar_range, temp_file
+
+
+
 def dcm2memmap(files, slice_size, orientation, resolution_percentage):
     """
     From a list of dicom files it creates memmap file in the temp folder and
@@ -462,7 +548,6 @@ def dcm2memmap(files, slice_size, orientation, resolution_percentage):
                                 resolution_percentage = resolution_percentage, update_progress = None)
             image = image_resized
-            print ">>>>>>>>>", image.GetDimensions()
         min_aux, max_aux = image.GetScalarRange()
         if min_scalar is None or min_aux < min_scalar:
@@ -482,7 +567,6 @@ def dcm2memmap(files, slice_size, orientation, resolution_percentage):
             # sagittal cases.
             matrix[:, :, n] = array
         else:
-            print array.shape, matrix.shape
             array.shape = matrix.shape[1], matrix.shape[2]
             matrix[n] = array
         update_progress(cont,message)
@@ -0,0 +1,903 @@
+import wx
+import vtk
+import vtkgdcm
+import time
+
+from vtk.util import  numpy_support
+from vtk.wx.wxVTKRenderWindowInteractor import wxVTKRenderWindowInteractor
+from wx.lib.pubsub import pub as Publisher
+
+import constants as const
+import data.vtk_utils as vtku
+from data import converters
+from reader import bitmap_reader
+import utils
+
+NROWS = 3
+NCOLS = 6
+NUM_PREVIEWS = NCOLS*NROWS
+PREVIEW_WIDTH = 70
+PREVIEW_HEIGTH = 70
+
+PREVIEW_BACKGROUND = (255, 255, 255) # White
+
+STR_SIZE = _("Image size: %d x %d")
+STR_SPC = _("Spacing: %.2f")
+STR_LOCAL = _("Location: %.2f")
+STR_PATIENT = "%s\n%s"
+STR_ACQ = _("%s %s\nMade in InVesalius")
+
+myEVT_PREVIEW_CLICK = wx.NewEventType()
+EVT_PREVIEW_CLICK = wx.PyEventBinder(myEVT_PREVIEW_CLICK, 1)
+
+myEVT_PREVIEW_DBLCLICK = wx.NewEventType()
+EVT_PREVIEW_DBLCLICK = wx.PyEventBinder(myEVT_PREVIEW_DBLCLICK, 1)
+
+myEVT_CLICK_SLICE = wx.NewEventType()
+# This event occurs when the user select a preview
+EVT_CLICK_SLICE = wx.PyEventBinder(myEVT_CLICK_SLICE, 1)
+
+myEVT_CLICK_SERIE = wx.NewEventType()
+# This event occurs when the user select a preview
+EVT_CLICK_SERIE = wx.PyEventBinder(myEVT_CLICK_SERIE, 1)
+
+myEVT_CLICK = wx.NewEventType()
+EVT_CLICK = wx.PyEventBinder(myEVT_CLICK, 1)
+
+
+class SelectionEvent(wx.PyCommandEvent):
+    pass
+
+
+class PreviewEvent(wx.PyCommandEvent):
+    def __init__(self , evtType, id):
+        super(PreviewEvent, self).__init__(evtType, id)
+
+    def GetSelectID(self):
+        return self.SelectedID
+
+    def SetSelectedID(self, id):
+        self.SelectedID = id
+
+    def GetItemData(self):
+        return self.data
+
+    def GetPressedShift(self):
+        return self.pressed_shift
+    
+    def SetItemData(self, data):
+        self.data = data
+
+    def SetShiftStatus(self, status):
+        self.pressed_shift = status
+    
+
+class SerieEvent(PreviewEvent):
+    def __init__(self , evtType, id):
+        super(SerieEvent, self).__init__(evtType, id)
+
+
+class BitmapInfo(object):
+    """
+    Keep the informations and the image used by preview.
+    """
+    def __init__(self, data):
+        #self.id = id
+        self.id = data[7]
+        self.title = data[6]
+        self.data = data
+        self.pos = data[8]
+        #self.subtitle = subtitle
+        self._preview = None
+        self.selected = False
+        #self.filename = ""
+        self.thumbnail_path = data[1]
+
+    @property
+    def preview(self):
+        
+        if not self._preview:
+            bmp = wx.Bitmap(self.thumbnail_path, wx.BITMAP_TYPE_PNG)
+            self._preview = bmp.ConvertToImage()
+        return self._preview
+        
+    def release_thumbnail(self):
+        self._preview = None
+
+class DicomPaintPanel(wx.Panel):
+    def __init__(self, parent):
+        super(DicomPaintPanel, self).__init__(parent)
+        self._bind_events()
+        self.image = None
+        self.last_size = (10,10)
+
+    def _bind_events(self):
+        self.Bind(wx.EVT_PAINT, self.OnPaint)
+        self.Bind(wx.EVT_SIZE, self.OnSize)
+
+    def _build_bitmap(self, image):
+        bmp = wx.BitmapFromImage(image)
+        return bmp
+
+    def _image_resize(self, image):
+        self.Update()
+        self.Layout()
+        new_size = self.GetSize()
+        # This is necessary due to darwin problem #
+        if new_size != (0,0):
+            self.last_size = new_size
+            return image.Scale(*new_size)
+        else:
+            return image.Scale(*self.last_size)
+
+    def SetImage(self, image):
+        self.image = image
+        r_img = self._image_resize(image)
+        self.bmp = self._build_bitmap(r_img)
+        self.Refresh()
+
+    def OnPaint(self, evt):
+        if self.image:
+            dc = wx.PaintDC(self)
+            dc.Clear()
+            dc.DrawBitmap(self.bmp, 0, 0)
+
+    def OnSize(self, evt):
+        if self.image:
+            self.bmp = self._build_bitmap(self._image_resize(self.image))
+        self.Refresh()
+        evt.Skip()
+
+
+class Preview(wx.Panel):
+    """
+    The little previews.
+    """
+    def __init__(self, parent):
+        super(Preview, self).__init__(parent)
+        # Will it be white?
+        self.select_on = False
+        self.bitmap_info = None
+        self._init_ui()
+        self._bind_events()
+
+    def _init_ui(self):
+        self.SetBackgroundColour(PREVIEW_BACKGROUND)
+
+        self.title = wx.StaticText(self, -1, _("Image"))
+        self.subtitle = wx.StaticText(self, -1, _("Image"))
+        self.image_viewer = DicomPaintPanel(self)
+
+        self.sizer = wx.BoxSizer(wx.VERTICAL)
+        self.sizer.Add(self.title, 0,
+                        wx.ALIGN_CENTER_HORIZONTAL)
+        self.sizer.Add(self.subtitle, 0,
+                        wx.ALIGN_CENTER_HORIZONTAL)
+        self.sizer.Add(self.image_viewer, 1, wx.ALIGN_CENTRE_HORIZONTAL \
+                       | wx.SHAPED | wx.ALL, 5)
+        self.sizer.Fit(self)
+
+        self.SetSizer(self.sizer)
+
+        self.Layout()
+        self.Update()
+        self.Fit()
+        self.SetAutoLayout(1)
+
+    def _bind_events(self):
+        self.Bind( wx.EVT_LEFT_DCLICK, self.OnDClick)
+        #self.interactor.Bind( wx.EVT_LEFT_DCLICK, self.OnDClick)
+        #self.panel.Bind( wx.EVT_LEFT_DCLICK, self.OnDClick)
+        #self.title.Bind( wx.EVT_LEFT_DCLICK, self.OnDClick)
+        #self.subtitle.Bind( wx.EVT_LEFT_DCLICK, self.OnDClick)
+
+        self.Bind(wx.EVT_ENTER_WINDOW, self.OnEnter)
+        #self.interactor.Bind(wx.EVT_ENTER_WINDOW, self.OnEnter)
+        #self.panel.Bind(wx.EVT_ENTER_WINDOW, self.OnEnter)
+        #self.title.Bind(wx.EVT_ENTER_WINDOW, self.OnEnter)
+        #self.subtitle.Bind(wx.EVT_ENTER_WINDOW, self.OnEnter)
+
+        self.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeave)
+        #self.interactor.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeave)
+        #self.panel.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeave)
+        #self.title.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeave)
+        #self.subtitle.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeave)
+
+        self.Bind(wx.EVT_LEFT_DOWN, self.OnSelect)
+        self.title.Bind(wx.EVT_LEFT_DOWN, self.OnSelect)
+        self.subtitle.Bind(wx.EVT_LEFT_DOWN, self.OnSelect)
+        self.image_viewer.Bind(wx.EVT_LEFT_DOWN, self.OnSelect)
+
+        #self.Bind(wx.EVT_SIZE, self.OnSize)
+
+    def SetBitmapToPreview(self, bitmap_info):
+        """
+        Set a dicom to preview.
+        """
+    
+        """
+        self.dicom_info = dicom_info
+        self.SetTitle(dicom_info.title)
+        self.SetSubtitle(dicom_info.subtitle)
+        self.ID = dicom_info.id
+        dicom_info.size = self.image_viewer.GetSize()
+        image = dicom_info.preview
+        self.image_viewer.SetImage(image)
+        self.data = dicom_info.id
+        self.select_on = dicom_info.selected
+        self.Select()
+        self.Update()
+        """
+
+
+
+        if self.bitmap_info:
+            self.bitmap_info.release_thumbnail()
+
+        self.bitmap_info = bitmap_info
+        self.SetTitle(self.bitmap_info.title[-10:])
+        self.SetSubtitle('')
+
+        ##self.ID = bitmap_info.id
+        ##bitmap_info.size = self.image_viewer.GetSize()
+        image = self.bitmap_info.preview
+        
+        self.image_viewer.SetImage(image)
+        #self.data = bitmap_info.id
+        self.select_on = bitmap_info.selected
+        self.Select()
+        self.Update()
+
+    def SetTitle(self, title):
+        self.title.SetLabel(title)
+
+    def SetSubtitle(self, subtitle):
+        self.subtitle.SetLabel(subtitle)
+
+    def OnEnter(self, evt):
+        if not self.select_on:
+            #c = wx.SystemSettings_GetColour(wx.SYS_COLOUR_3DHILIGHT)
+            c = wx.SystemSettings_GetColour(wx.SYS_COLOUR_BTNFACE)
+            self.SetBackgroundColour(c)
+
+    def OnLeave(self, evt):
+        if not self.select_on:
+            c = (PREVIEW_BACKGROUND)
+            self.SetBackgroundColour(c)
+
+    def OnSelect(self, evt):
+
+        shift_pressed = False
+        if evt.m_shiftDown:
+            shift_pressed = True
+
+        dicom_id = self.bitmap_info.id
+        self.select_on = True
+        self.bitmap_info.selected = True
+        self.Select()
+
+        # Generating a EVT_PREVIEW_CLICK event
+        my_evt = SerieEvent(myEVT_PREVIEW_CLICK, self.GetId())
+
+        my_evt.SetSelectedID(self.bitmap_info.id)
+        my_evt.SetItemData(self.bitmap_info.data)
+
+        my_evt.SetShiftStatus(shift_pressed)
+        my_evt.SetEventObject(self)
+        self.GetEventHandler().ProcessEvent(my_evt)
+
+        Publisher.sendMessage('Set bitmap in preview panel', self.bitmap_info.pos)
+
+        evt.Skip()
+        
+
+    def OnSize(self, evt):
+        if self.bitmap_info:
+            self.SetBitmapToPreview(self.bitmap_info)
+        evt.Skip()
+
+    def Select(self, on=True):
+        if self.select_on:
+            c = wx.SystemSettings_GetColour(wx.SYS_COLOUR_HIGHLIGHT)
+        else:
+            c = (PREVIEW_BACKGROUND)
+        self.SetBackgroundColour(c)
+        self.Refresh()
+
+    def OnDClick(self, evt):
+        my_evt = SerieEvent(myEVT_PREVIEW_DBLCLICK, self.GetId())
+        my_evt.SetSelectedID(self.bitmap_info.id)
+        my_evt.SetItemData(self.bitmap_info.data)
+        my_evt.SetEventObject(self)
+        self.GetEventHandler().ProcessEvent(my_evt)
+        evt.Skip()
+
+
+class BitmapPreviewSeries(wx.Panel):
+    """A dicom series preview panel"""
+    def __init__(self, parent):
+        super(BitmapPreviewSeries, self).__init__(parent)
+        # TODO: 3 pixels between the previews is a good idea?
+        # I have to test.
+        #self.sizer = wx.BoxSizer(wx.HORIZONTAL)
+        #self.SetSizer(self.sizer)
+        self.displayed_position = 0
+        self.nhidden_last_display = 0
+        self.selected_dicom = None
+        self.selected_panel = None
+        self._init_ui()
+
+    def _init_ui(self):
+        scroll = wx.ScrollBar(self, -1, style=wx.SB_VERTICAL)
+        self.scroll = scroll
+
+        self.grid = wx.GridSizer(rows=NROWS, cols=NCOLS, vgap=3, hgap=3)
+
+        sizer = wx.BoxSizer(wx.HORIZONTAL)
+        sizer.AddSizer(self.grid, 1, wx.EXPAND|wx.GROW|wx.ALL, 2)
+
+        background_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        background_sizer.AddSizer(sizer, 1, wx.EXPAND|wx.GROW|wx.ALL, 2)
+        background_sizer.Add(scroll, 0, wx.EXPAND|wx.GROW)
+        self.SetSizer(background_sizer)
+        background_sizer.Fit(self)
+
+        self.Layout()
+        self.Update()
+        self.SetAutoLayout(1)
+
+        self.sizer = background_sizer
+
+        self._Add_Panels_Preview()
+        self._bind_events()
+
+    def _Add_Panels_Preview(self):
+        self.previews = []
+        for i in xrange(NROWS):
+            for j in xrange(NCOLS):
+                p = Preview(self)
+                p.Bind(EVT_PREVIEW_CLICK, self.OnSelect)
+                #if (i == j == 0):
+                    #self._show_shadow(p)
+                #p.Hide()
+                self.previews.append(p)
+                self.grid.Add(p, 1, flag=wx.EXPAND)
+
+    #def _show_shadow(self, preview):
+    #    preview.ShowShadow()
+
+    def _bind_events(self):
+        # When the user scrolls the window
+        self.Bind(wx.EVT_SCROLL, self.OnScroll)
+        self.Bind(wx.EVT_MOUSEWHEEL, self.OnWheel)
+
+    def OnSelect(self, evt):
+        my_evt = SerieEvent(myEVT_CLICK_SERIE, self.GetId())
+        my_evt.SetSelectedID(evt.GetSelectID())
+        my_evt.SetItemData(evt.GetItemData())
+
+        if self.selected_dicom:
+            self.selected_dicom.selected = self.selected_dicom is \
+                    evt.GetEventObject().bitmap_info
+            self.selected_panel.select_on = self.selected_panel is evt.GetEventObject()
+            self.selected_panel.Select()
+        self.selected_panel = evt.GetEventObject()
+        self.selected_dicom = self.selected_panel.bitmap_info
+        self.GetEventHandler().ProcessEvent(my_evt)
+        evt.Skip()
+
+    def SetBitmapFiles(self, data):
+        #self.files = data
+        self.files = []
+        
+        bitmap = bitmap_reader.BitmapData()
+        bitmap.SetData(data)
+
+        pos = 0
+        for d in data:
+            d.append(pos)
+            info = BitmapInfo(d)
+            self.files.append(info)
+            pos += 1
+
+        scroll_range = len(self.files)/NCOLS
+        if scroll_range * NCOLS < len(self.files):
+            scroll_range +=1
+        self.scroll.SetScrollbar(0, NROWS, scroll_range, NCOLS)
+        self._display_previews()
+
+    
+    #def SetPatientGroups(self, patient):
+    #    self.files = []
+    #    self.displayed_position = 0
+    #    self.nhidden_last_display = 0
+    #    group_list = patient.GetGroups()
+    #    self.group_list = group_list
+    #    n = 0
+    #    for group in group_list:
+    #        info = BitmapInfo((group.dicom.patient.id,
+    #                          group.dicom.acquisition.serie_number),
+    #                         group.dicom,
+    #                         group.title,
+    #                         _("%d images") %(group.nslices))
+    #        self.files.append(info)
+    #        n+=1
+    #    scroll_range = len(self.files)/NCOLS
+    #    if scroll_range * NCOLS < len(self.files):
+    #        scroll_range +=1
+    #    self.scroll.SetScrollbar(0, NROWS, scroll_range, NCOLS)
+    #    self._display_previews()
+
+
+    def _display_previews(self):
+        initial = self.displayed_position * NCOLS
+        final = initial + NUM_PREVIEWS
+        if len(self.files) < final:
+            for i in xrange(final-len(self.files)):
+                try:
+                    self.previews[-i-1].Hide()
+                except IndexError:
+                    utils.debug("doesn't exist!")
+                    pass
+            self.nhidden_last_display = final-len(self.files)
+        else:
+            if self.nhidden_last_display:
+                for i in xrange(self.nhidden_last_display):
+                    try:
+                        self.previews[-i-1].Show()
+                    except IndexError:
+                        utils.debug("doesn't exist!")
+                        pass
+                self.nhidden_last_display = 0
+
+        for f, p in zip(self.files[initial:final], self.previews):
+            p.SetBitmapToPreview(f)
+            if f.selected:
+                self.selected_panel = p
+
+        for f, p in zip(self.files[initial:final], self.previews):
+            p.Show()
+
+
+    def OnScroll(self, evt=None):
+        if evt:
+            if self.displayed_position != evt.GetPosition():
+                self.displayed_position = evt.GetPosition()
+        else:
+            if self.displayed_position != self.scroll.GetThumbPosition():
+                self.displayed_position = self.scroll.GetThumbPosition()
+        self._display_previews()
+
+    def OnWheel(self, evt):
+        d = evt.GetWheelDelta() / evt.GetWheelRotation()
+        self.scroll.SetThumbPosition(self.scroll.GetThumbPosition() - d)
+        self.OnScroll()
+
+
+class SingleImagePreview(wx.Panel):
+    def __init__(self, parent):
+        wx.Panel.__init__(self, parent, -1)
+        self.actor = None
+        self.__init_gui()
+        self.__init_vtk()
+        self.__bind_evt_gui()
+        self.__bind_pubsub()
+        self.dicom_list = []
+        self.nimages = 1
+        self.current_index = 0
+        self.window_width = const.WINDOW_LEVEL[_("Bone")][0]
+        self.window_level = const.WINDOW_LEVEL[_("Bone")][1]
+
+    def __init_vtk(self):
+        text_image_size = vtku.Text()
+        text_image_size.SetPosition(const.TEXT_POS_LEFT_UP)
+        text_image_size.SetValue("")
+        text_image_size.SetSize(const.TEXT_SIZE_SMALL)
+        self.text_image_size = text_image_size
+
+        text_image_location = vtku.Text()
+        text_image_location.SetVerticalJustificationToBottom()
+        text_image_location.SetPosition(const.TEXT_POS_LEFT_DOWN)
+        text_image_location.SetValue("")
+        text_image_location.SetSize(const.TEXT_SIZE_SMALL)
+        self.text_image_location = text_image_location
+
+        text_patient = vtku.Text()
+        text_patient.SetJustificationToRight()
+        text_patient.SetPosition(const.TEXT_POS_RIGHT_UP)
+        text_patient.SetValue("")
+        text_patient.SetSize(const.TEXT_SIZE_SMALL)
+        self.text_patient = text_patient
+
+        text_acquisition = vtku.Text()
+        text_acquisition.SetJustificationToRight()
+        text_acquisition.SetVerticalJustificationToBottom()
+        text_acquisition.SetPosition(const.TEXT_POS_RIGHT_DOWN)
+        text_acquisition.SetValue("")
+        text_acquisition.SetSize(const.TEXT_SIZE_SMALL)
+        self.text_acquisition = text_acquisition
+
+        renderer = vtk.vtkRenderer()
+        renderer.AddActor(text_image_size.actor)
+        renderer.AddActor(text_image_location.actor)
+        renderer.AddActor(text_patient.actor)
+        renderer.AddActor(text_acquisition.actor)
+        self.renderer = renderer
+
+        style = vtk.vtkInteractorStyleImage()
+
+        interactor = wxVTKRenderWindowInteractor(self.panel, -1,
+                                    size=wx.Size(340,340))
+        interactor.GetRenderWindow().AddRenderer(renderer)
+        interactor.SetInteractorStyle(style)
+        interactor.Render()
+        self.interactor = interactor
+
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(interactor, 1, wx.GROW|wx.EXPAND)
+        sizer.Fit(self.panel)
+        self.panel.SetSizer(sizer)
+        self.Layout()
+        self.Update()
+
+    def __init_gui(self):
+        self.panel = wx.Panel(self, -1)
+
+        slider = wx.Slider(self,
+                            id=-1,
+                            value=0,
+                            minValue=0,
+                            maxValue=99,
+                            style=wx.SL_HORIZONTAL|wx.SL_AUTOTICKS)
+        slider.SetWindowVariant(wx.WINDOW_VARIANT_SMALL)
+        slider.SetTickFreq(1, 1)
+        self.slider = slider
+
+        checkbox = wx.CheckBox(self, -1, _("Auto-play"))
+        self.checkbox = checkbox
+
+        in_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        in_sizer.Add(slider, 1, wx.GROW|wx.EXPAND)
+        in_sizer.Add(checkbox, 0)
+
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(self.panel, 20, wx.GROW|wx.EXPAND)
+        sizer.Add(in_sizer, 1, wx.GROW|wx.EXPAND)
+        sizer.Fit(self)
+
+        self.SetSizer(sizer)
+        self.Layout()
+        self.Update()
+        self.SetAutoLayout(1)
+
+    def __bind_evt_gui(self):
+        self.slider.Bind(wx.EVT_SLIDER, self.OnSlider)
+        self.checkbox.Bind(wx.EVT_CHECKBOX, self.OnCheckBox)
+
+    def __bind_pubsub(self):
+        Publisher.subscribe(self.ShowBitmapByPosition, 'Set bitmap in preview panel')
+
+    def ShowBitmapByPosition(self, evt):
+        pos = evt.data 
+        self.ShowSlice(pos)
+
+
+    def OnSlider(self, evt):
+        pos = evt.GetInt()
+        self.ShowSlice(pos)
+        evt.Skip()
+
+    def OnCheckBox(self, evt):
+        self.ischecked = evt.IsChecked()
+        if evt.IsChecked():
+            wx.CallAfter(self.OnRun)
+        evt.Skip()
+
+    def OnRun(self):
+        pos = self.slider.GetValue()
+        pos += 1
+        if not (self.nimages- pos):
+            pos = 0
+        self.slider.SetValue(pos)
+        self.ShowSlice(pos)
+        time.sleep(0.2)
+        if self.ischecked:
+            try:
+                wx.Yield()
+            #TODO: temporary fix necessary in the Windows XP 64 Bits
+            #BUG in wxWidgets http://trac.wxwidgets.org/ticket/10896
+            except(wx._core.PyAssertionError):
+                utils.debug("wx._core.PyAssertionError")
+            finally:
+                wx.CallAfter(self.OnRun)
+
+    def SetBitmapFiles(self, data):
+        #self.dicom_list = group.GetHandSortedList()
+        self.bitmap_list = data
+        self.current_index = 0
+        self.nimages = len(data)
+        # GUI
+        self.slider.SetMax(self.nimages-1)
+        self.slider.SetValue(0)
+        self.ShowSlice()
+
+    def ShowSlice(self, index = 0):
+        bitmap = self.bitmap_list[index]
+
+        # UPDATE GUI
+        ## Text related to size
+        value = STR_SIZE %(bitmap[3], bitmap[4])
+        self.text_image_size.SetValue(value)
+
+        value1 = ''
+        value2 = ''
+
+        value = "%s\n%s" %(value1, value2)
+        self.text_image_location.SetValue(value)
+
+
+        #self.text_patient.SetValue(value)
+        self.text_patient.SetValue('')
+
+        #self.text_acquisition.SetValue(value)
+        self.text_acquisition.SetValue('')
+
+
+
+        n_array = bitmap_reader.ReadBitmap(bitmap[0])
+        
+        image = converters.to_vtk(n_array, spacing=(1,1,1),\
+                slice_number=1, orientation="AXIAL")
+
+
+        # ADJUST CONTRAST
+        window_level = n_array.max()/2
+        window_width = n_array.max()
+        
+        colorer = vtk.vtkImageMapToWindowLevelColors()
+        colorer.SetInputData(image)
+        colorer.SetWindow(float(window_width))
+        colorer.SetLevel(float(window_level))
+        colorer.Update()
+
+        if self.actor is None:
+            self.actor = vtk.vtkImageActor()
+            self.renderer.AddActor(self.actor)
+
+        # PLOT IMAGE INTO VIEWER
+        self.actor.SetInputData(colorer.GetOutput())
+        self.renderer.ResetCamera()
+        self.interactor.Render()
+
+        # Setting slider position
+        self.slider.SetValue(index)
+
+
+#class BitmapPreviewSlice(wx.Panel):
+#    def __init__(self, parent):
+#        super(BitmapPreviewSlice, self).__init__(parent)
+#        # TODO: 3 pixels between the previews is a good idea?
+#        # I have to test.
+#        self.displayed_position = 0
+#        self.nhidden_last_display = 0
+#        self.selected_dicom = None
+#        self.selected_panel = None
+#        self.first_selection = None
+#        self.last_selection = None
+#        self._init_ui()
+#
+#    def _init_ui(self):
+#        scroll = wx.ScrollBar(self, -1, style=wx.SB_VERTICAL)
+#        self.scroll = scroll
+#
+#        self.grid = wx.GridSizer(rows=NROWS, cols=NCOLS, vgap=3, hgap=3)
+#
+#        sizer = wx.BoxSizer(wx.HORIZONTAL)
+#        sizer.AddSizer(self.grid, 1, wx.EXPAND|wx.GROW|wx.ALL, 2)
+#
+#        background_sizer = wx.BoxSizer(wx.HORIZONTAL)
+#        background_sizer.AddSizer(sizer, 1, wx.EXPAND|wx.GROW|wx.ALL, 2)
+#        background_sizer.Add(scroll, 0, wx.EXPAND|wx.GROW)
+#        self.SetSizer(background_sizer)
+#        background_sizer.Fit(self)
+#
+#        self.Layout()
+#        self.Update()
+#        self.SetAutoLayout(1)
+#
+#        self.sizer = background_sizer
+#
+#        self._Add_Panels_Preview()
+#        self._bind_events()
+#
+#    def _Add_Panels_Preview(self):
+#        self.previews = []
+#        for i in xrange(NROWS):
+#            for j in xrange(NCOLS):
+#                p = Preview(self)
+#                p.Bind(EVT_PREVIEW_CLICK, self.OnPreviewClick)
+#                #p.Hide()
+#                self.previews.append(p)
+#                self.grid.Add(p, 1, flag=wx.EXPAND)
+#
+#    def _bind_events(self):
+#        # When the user scrolls the window
+#        self.Bind(wx.EVT_SCROLL, self.OnScroll)
+#        self.Bind(wx.EVT_MOUSEWHEEL, self.OnWheel)
+#
+#    def SetDicomDirectory(self, directory):
+#        utils.debug("Setting Dicom Directory %s" % directory)
+#        self.directory = directory
+#        self.series = dicom_reader.GetSeries(directory)[0]
+#
+#    def SetPatientGroups(self, patient):
+#        self.group_list = patient.GetGroups()
+#
+#
+#    #def SetDicomSerie(self, pos):
+#    #    self.files = []
+#    #    self.displayed_position = 0
+#    #    self.nhidden_last_display = 0
+#    #    group = self.group_list[pos]
+#    #    self.group = group
+#    #    #dicom_files = group.GetList()
+#    #    dicom_files = group.GetHandSortedList()
+#    #    n = 0
+#    #    for dicom in dicom_files:
+#    #        info = BitmapInfo(n, dicom,
+#    #                         _("Image %d") % (dicom.image.number),
+#    #                         "%.2f" % (dicom.image.position[2]))
+#    #        self.files.append(info)
+#    #        n+=1
+#
+#    #    scroll_range = len(self.files)/NCOLS
+#    #    if scroll_range * NCOLS < len(self.files):
+#    #        scroll_range +=1
+#    #    self.scroll.SetScrollbar(0, NROWS, scroll_range, NCOLS)
+#    
+#    #    self._display_previews()
+#
+#    #def SetDicomGroup(self, group):
+#    #    self.files = []
+#    #    self.displayed_position = 0
+#    #    self.nhidden_last_display = 0
+#    #    #dicom_files = group.GetList()
+#    #    dicom_files = group.GetHandSortedList()
+#    #    n = 0
+#    #    for dicom in dicom_files:
+#    #        info = BitmapInfo(n, dicom,
+#    #                         _("Image %d") % (dicom.image.number),
+#    #                         "%.2f" % (dicom.image.position[2]),
+#    #                        )
+#    #        self.files.append(info)
+#    #        n+=1
+#
+#    #    scroll_range = len(self.files)/NCOLS
+#    #    if scroll_range * NCOLS < len(self.files):
+#    #        scroll_range +=1
+#    #    self.scroll.SetScrollbar(0, NROWS, scroll_range, NCOLS)
+#
+#    #    self._display_previews()
+#
+#    #def SetDicomGroup(self, group):
+#    #    self.files = []
+#    #    self.displayed_position = 0
+#    #    self.nhidden_last_display = 0
+#    #    #dicom_files = group.GetList()
+#    #    dicom_files = group.GetHandSortedList()
+#    #    n = 0
+#    #    for dicom in dicom_files:
+#    #        info = BitmapInfo(n, dicom,
+#    #                         _("Image %d") % (dicom.image.number),
+#    #                         "%.2f" % (dicom.image.position[2]),
+#    #                        )
+#    #        self.files.append(info)
+#    #        n+=1
+#
+#    #    scroll_range = len(self.files)/NCOLS
+#    #    if scroll_range * NCOLS < len(self.files):
+#    #        scroll_range +=1
+#    #    self.scroll.SetScrollbar(0, NROWS, scroll_range, NCOLS)
+#
+#    #    self._display_previews()
+#
+#
+#    def _display_previews(self):
+#        initial = self.displayed_position * NCOLS
+#        final = initial + NUM_PREVIEWS
+#        if len(self.files) < final:
+#            for i in xrange(final-len(self.files)):
+#                try:
+#                    self.previews[-i-1].Hide()
+#                except IndexError:
+#                    utils.debug("doesn't exist!")
+#            self.nhidden_last_display = final-len(self.files)
+#        else:
+#            if self.nhidden_last_display:
+#                for i in xrange(self.nhidden_last_display):
+#                    try:
+#                        self.previews[-i-1].Show()
+#                    except IndexError:
+#                        utils.debug("doesn't exist!")
+#                self.nhidden_last_display = 0
+#
+#        for f, p in zip(self.files[initial:final], self.previews):
+#            p.SetBitmapToPreview(f)
+#            if f.selected:
+#                self.selected_panel = p
+#            #p.interactor.Render()
+#
+#        for f, p in zip(self.files[initial:final], self.previews):
+#            p.Show()
+#
+#    def OnPreviewClick(self, evt):
+#
+#        dicom_id = evt.GetSelectID()
+#        
+#        if self.first_selection is None:
+#            self.first_selection = dicom_id
+#
+#        if self.last_selection is None:
+#            self.last_selection = dicom_id  
+#
+#        
+#        if evt.GetPressedShift():
+# 
+#            if dicom_id < self.first_selection and dicom_id < self.last_selection:
+#                self.first_selection = dicom_id
+#            else:
+#                self.last_selection = dicom_id
+#        else:
+#            self.first_selection = dicom_id
+#            self.last_selection = dicom_id
+#
+#            for i in xrange(len(self.files)):
+#            
+#                if i == dicom_id:
+#                    self.files[i].selected = True
+#                else:
+#                    self.files[i].selected = False
+#
+#
+#        my_evt = SerieEvent(myEVT_CLICK_SLICE, self.GetId())
+#        my_evt.SetSelectedID(evt.GetSelectID())
+#        my_evt.SetItemData(evt.GetItemData())
+#
+#        if self.selected_dicom:
+#            self.selected_dicom.selected = self.selected_dicom is \
+#                    evt.GetEventObject().bitmap_info
+#            self.selected_panel.select_on = self.selected_panel is evt.GetEventObject()
+#            
+#            if self.first_selection != self.last_selection:
+#                for i in xrange(len(self.files)):
+#                    if i >= self.first_selection and i <= self.last_selection:
+#                        self.files[i].selected = True
+#                    else:
+#                        self.files[i].selected = False
+#
+#            else:
+#                self.selected_panel.Select()
+#
+#        self._display_previews()
+#        self.selected_panel = evt.GetEventObject()
+#        self.selected_dicom = self.selected_panel.bitmap_info
+#        self.GetEventHandler().ProcessEvent(my_evt)
+#
+#        #Publisher.sendMessage("Selected Import Images", [self.first_selection, \
+#        #                                                         self.last_selection])  
+#
+#    def OnScroll(self, evt=None):
+#        if evt:
+#            if self.displayed_position != evt.GetPosition():
+#                self.displayed_position = evt.GetPosition()
+#        else:
+#            if self.displayed_position != self.scroll.GetThumbPosition():
+#                self.displayed_position = self.scroll.GetThumbPosition()
+#        self._display_previews()
+#
+#    def OnWheel(self, evt):
+#        d = evt.GetWheelDelta() / evt.GetWheelRotation()
+#        self.scroll.SetThumbPosition(self.scroll.GetThumbPosition() - d)
+#        self.OnScroll()
+
+
@@ -39,6 +39,12 @@ from gui.widgets.clut_imagedata import CLUTImageDataWidget, EVT_CLUT_NODE_CHANGE
 import numpy as np
+try:
+    from agw import floatspin as FS
+except ImportError: # if it's not there locally, try the wxPython lib.
+    import wx.lib.agw.floatspin as FS
+
+
 class MaskEvent(wx.PyCommandEvent):
     def __init__(self , evtType, id, mask_index):
         wx.PyCommandEvent.__init__(self, evtType, id,)
@@ -306,6 +312,48 @@ def ShowImportDirDialog():
     os.chdir(current_dir)
     return path
+def ShowImportBitmapDirDialog():
+    current_dir = os.path.abspath(".")
+
+    if (sys.platform == 'win32') or (sys.platform == 'linux2'):
+        session = ses.Session()
+
+        if (session.GetLastDicomFolder()):
+            folder = session.GetLastDicomFolder()
+        else:
+            folder = ''
+    else:
+        folder = ''
+
+    dlg = wx.DirDialog(None, _("Choose a folder with TIFF, BMP, JPG or PNG:"), folder,
+                        style=wx.DD_DEFAULT_STYLE
+                        | wx.DD_DIR_MUST_EXIST
+                        | wx.DD_CHANGE_DIR)
+
+    path = None
+    try:
+        if dlg.ShowModal() == wx.ID_OK:
+            # GetPath returns in unicode, if a path has non-ascii characters a
+            # UnicodeEncodeError is raised. To avoid this, path is encoded in utf-8
+            if sys.platform == "win32":
+                path = dlg.GetPath()
+            else:
+                path = dlg.GetPath().encode('utf-8')
+
+    except(wx._core.PyAssertionError): #TODO: error win64
+         if (dlg.GetPath()):
+             path = dlg.GetPath()
+
+    if (sys.platform != 'darwin'):
+        if (path):
+            session.SetLastDicomFolder(path)
+
+    # Only destroy a dialog after you're done with it.
+    dlg.Destroy()
+    os.chdir(current_dir)
+    return path
+
+
 def ShowSaveAsProjectDialog(default_filename=None):
     current_dir = os.path.abspath(".")
     dlg = wx.FileDialog(None,
@@ -1630,3 +1678,114 @@ class ReorientImageDialog(wx.Dialog):
         Publisher.sendMessage('Disable style', const.SLICE_STATE_REORIENT)
         Publisher.sendMessage('Enable style', const.STATE_DEFAULT)
         self.Destroy()
+
+
+
+class ImportBitmapParameters(wx.Dialog):
+
+    def __init__(self):
+        pre = wx.PreDialog()
+        pre.Create(wx.GetApp().GetTopWindow(), -1, _(u"Parameters"),size=wx.Size(380,230),\
+                                style=wx.DEFAULT_DIALOG_STYLE|wx.FRAME_FLOAT_ON_PARENT|wx.STAY_ON_TOP)
+
+        self.interval = 0
+        
+        self.PostCreate(pre)
+
+        self._init_gui()
+
+        self.bind_evts()
+        self.CenterOnScreen()
+
+
+    def _init_gui(self):
+        
+        
+        p = wx.Panel(self, -1, style = wx.TAB_TRAVERSAL
+                     | wx.CLIP_CHILDREN
+                     | wx.FULL_REPAINT_ON_RESIZE)
+       
+        gbs_principal = self.gbs = wx.GridBagSizer(3,1)
+
+        gbs = self.gbs = wx.GridBagSizer(4, 2)
+        
+        stx_name = wx.StaticText(p, -1, _(u"Project name:"))
+        tx_name = self.tx_name = wx.TextCtrl(p, -1, "InVesalius Bitmap", size=wx.Size(220,-1))
+
+        stx_orientation = wx.StaticText(p, -1, _(u"Slices orientation:"))
+        cb_orientation_options = [_(u'Axial'), _(u'Coronal'), _(u'Sagital')]
+        cb_orientation = self.cb_orientation = wx.ComboBox(p, value="Axial", choices=cb_orientation_options,\
+                                                size=wx.Size(160,-1), style=wx.CB_DROPDOWN|wx.CB_READONLY)
+
+        stx_spacing = wx.StaticText(p, -1, _(u"Spacing (mm):"))
+
+        gbs.Add(stx_name, (0,0))
+        gbs.Add(tx_name, (0,1))
+
+        gbs.Add(stx_orientation, (1,0))
+        gbs.Add(cb_orientation, (1,1))
+
+        gbs.Add(stx_spacing, (2,0))
+
+        #--- spacing --------------
+        gbs_spacing = wx.GridBagSizer(2, 6)
+        
+        stx_spacing_x = stx_spacing_x = wx.StaticText(p, -1, _(u"X:"))
+        fsp_spacing_x = self.fsp_spacing_x = FS.FloatSpin(p, -1, min_val=0,\
+                                            increment=0.25, value=1.0, digits=6)
+
+        stx_spacing_y = stx_spacing_y = wx.StaticText(p, -1, _(u"Y:"))
+        fsp_spacing_y = self.fsp_spacing_y = FS.FloatSpin(p, -1, min_val=0,\
+                                            increment=0.25, value=1.0, digits=6)
+
+        stx_spacing_z = stx_spacing_z = wx.StaticText(p, -1, _(u"Z:"))
+        fsp_spacing_z = self.fsp_spacing_z = FS.FloatSpin(p, -1, min_val=0,\
+                                            increment=0.25, value=1.0, digits=6)
+
+        gbs_spacing.Add(stx_spacing_x, (0,0))
+        gbs_spacing.Add(fsp_spacing_x, (0,1))
+
+        gbs_spacing.Add(stx_spacing_y, (0,2))
+        gbs_spacing.Add(fsp_spacing_y, (0,3))
+
+        gbs_spacing.Add(stx_spacing_z, (0,4))
+        gbs_spacing.Add(fsp_spacing_z, (0,5))
+
+        #----- buttons ------------------------
+        gbs_button = wx.GridBagSizer(1, 4)
+ 
+        btn_ok = self.btn_ok= wx.Button(p, wx.ID_OK)
+        btn_ok.SetDefault()
+
+        btn_cancel = wx.Button(p, wx.ID_CANCEL)
+
+        gbs_button.Add(btn_cancel, (1,2))
+        gbs_button.Add(btn_ok, (1,3))
+
+
+        gbs_principal.Add(gbs, (0,0))
+        gbs_principal.Add(gbs_spacing, (1,0))
+        gbs_principal.Add(gbs_button, (2,0), flag = wx.ALIGN_RIGHT)
+
+        box = wx.BoxSizer()
+        box.Add(gbs_principal, 1, wx.ALL|wx.EXPAND, 10)
+        
+        p.SetSizer(box)
+
+
+    def bind_evts(self):
+        self.btn_ok.Bind(wx.EVT_BUTTON, self.OnOk)
+   
+    def SetInterval(self, v):
+        self.interval = v
+
+    def OnOk(self, evt):
+        self.Close()
+        self.Destroy()
+
+        values = [self.tx_name.GetValue(), self.cb_orientation.GetValue().upper(),\
+                  self.fsp_spacing_x.GetValue(), self.fsp_spacing_y.GetValue(),\
+                  self.fsp_spacing_z.GetValue(), self.interval]
+        Publisher.sendMessage('Open bitmap files', values)
+
+
@@ -36,6 +36,7 @@ import default_tasks as tasks
 import default_viewers as viewers
 import gui.dialogs as dlg
 import import_panel as imp
+import import_bitmap_panel as imp_bmp
 import import_network_panel as imp_net
 import project as prj
 import session as ses
@@ -126,6 +127,7 @@ class Frame(wx.Frame):
         sub(self._ShowImportPanel, 'Show import panel in frame')
         #sub(self._ShowHelpMessage, 'Show help message')
         sub(self._ShowImportNetwork, 'Show retrieve dicom panel')
+        sub(self._ShowImportBitmap, 'Show import bitmap panel in frame')
         sub(self._ShowTask, 'Show task panel')
         sub(self._UpdateAUI, 'Update AUI')
         sub(self._Exit, 'Exit')
@@ -170,8 +172,14 @@ class Frame(wx.Frame):
         # are shown, this should be hiden
         caption = _("Preview medical data to be reconstructed")
         aui_manager.AddPane(imp.Panel(self), wx.aui.AuiPaneInfo().
-                          Name("Import").Centre().Hide().
-                          MaximizeButton(True).Floatable(True).
+                          Name("Import").CloseButton(False).Centre().Hide().
+                          MaximizeButton(False).Floatable(True).
+                          Caption(caption).CaptionVisible(True))
+
+        caption = _("Preview bitmap to be reconstructed")
+        aui_manager.AddPane(imp_bmp.Panel(self), wx.aui.AuiPaneInfo().
+                          Name("ImportBMP").CloseButton(False).Centre().Hide().
+                          MaximizeButton(False).Floatable(True).
                           Caption(caption).CaptionVisible(True))
         ncaption = _("Retrieve DICOM from PACS")
@@ -298,6 +306,9 @@ class Frame(wx.Frame):
         Publisher.sendMessage("Set layout button full")
         aui_manager = self.aui_manager
         aui_manager.GetPane("Import").Show(0)
+        
+        aui_manager.GetPane("ImportBMP").Show(0)
+
         aui_manager.GetPane("Data").Show(1)
         aui_manager.GetPane("Tasks").Show(1)
         aui_manager.Update()
@@ -314,6 +325,18 @@ class Frame(wx.Frame):
         aui_manager.GetPane("Import").Show(0)
         aui_manager.Update()
+    def _ShowImportBitmap(self, evt_pubsub):
+        """
+        Show viewers and task, hide import panel.
+        """
+        Publisher.sendMessage("Set layout button full")
+        aui_manager = self.aui_manager
+        aui_manager.GetPane("ImportBMP").Show(1)
+        aui_manager.GetPane("Data").Show(0)
+        aui_manager.GetPane("Tasks").Show(0)
+        aui_manager.GetPane("Import").Show(0)
+        aui_manager.Update()
+
     def _ShowHelpMessage(self, evt_pubsub):
         aui_manager = self.aui_manager
         pos = aui_manager.GetPane("Data").window.GetScreenPosition()
@@ -371,6 +394,8 @@ class Frame(wx.Frame):
             self.ShowOpenProject()
         elif id == const.ID_ANALYZE_IMPORT:
             self.ShowAnalyzeImporter()
+        elif id == const.ID_TIFF_JPG_PNG:
+            self.ShowBitmapImporter()
         elif id == const.ID_PROJECT_SAVE:
             session = ses.Session()
             if session.temp_item:
@@ -501,6 +526,12 @@ class Frame(wx.Frame):
         """
         Publisher.sendMessage('Show analyze dialog', True)
+    def ShowBitmapImporter(self):
+        """
+        Tiff, BMP, JPEG and PNG
+        """
+        Publisher.sendMessage('Show bitmap dialog', True)
+
     def FlipVolume(self, axis):
         Publisher.sendMessage('Flip volume', axis)
         Publisher.sendMessage('Reload actual slice')
@@ -581,6 +612,7 @@ class MenuBar(wx.MenuBar):
         #Import Others Files
         others_file_menu = wx.Menu()
         others_file_menu.Append(const.ID_ANALYZE_IMPORT, "Analyze")
+        others_file_menu.Append(const.ID_TIFF_JPG_PNG, "TIFF,BMP,JPG or PNG")
         # FILE
         file_menu = wx.Menu()
@@ -0,0 +1,484 @@
+#--------------------------------------------------------------------------
+# Software:     InVesalius - Software de Reconstrucao 3D de Imagens Medicas
+# Copyright:    (C) 2001  Centro de Pesquisas Renato Archer
+# Homepage:     http://www.softwarepublico.gov.br
+# Contact:      invesalius@cti.gov.br
+# License:      GNU - GPL 2 (LICENSE.txt/LICENCA.txt)
+#--------------------------------------------------------------------------
+#    Este programa e software livre; voce pode redistribui-lo e/ou
+#    modifica-lo sob os termos da Licenca Publica Geral GNU, conforme
+#    publicada pela Free Software Foundation; de acordo com a versao 2
+#    da Licenca.
+#
+#    Este programa eh distribuido na expectativa de ser util, mas SEM
+#    QUALQUER GARANTIA; sem mesmo a garantia implicita de
+#    COMERCIALIZACAO ou de ADEQUACAO A QUALQUER PROPOSITO EM
+#    PARTICULAR. Consulte a Licenca Publica Geral GNU para obter mais
+#    detalhes.
+#--------------------------------------------------------------------------
+import wx
+import wx.gizmos as gizmos
+from wx.lib.pubsub import pub as Publisher
+import wx.lib.splitter as spl
+
+import constants as const
+import gui.dialogs as dlg
+import bitmap_preview_panel as bpp
+import reader.dicom_grouper as dcm
+from dialogs import ImportBitmapParameters
+
+myEVT_SELECT_SERIE = wx.NewEventType()
+EVT_SELECT_SERIE = wx.PyEventBinder(myEVT_SELECT_SERIE, 1)
+
+myEVT_SELECT_SLICE = wx.NewEventType()
+EVT_SELECT_SLICE = wx.PyEventBinder(myEVT_SELECT_SLICE, 1)
+
+myEVT_SELECT_PATIENT = wx.NewEventType()
+EVT_SELECT_PATIENT = wx.PyEventBinder(myEVT_SELECT_PATIENT, 1)
+
+myEVT_SELECT_SERIE_TEXT = wx.NewEventType()
+EVT_SELECT_SERIE_TEXT = wx.PyEventBinder(myEVT_SELECT_SERIE_TEXT, 1)
+
+class SelectEvent(wx.PyCommandEvent):
+    def __init__(self , evtType, id):
+        super(SelectEvent, self).__init__(evtType, id)
+
+    def GetSelectID(self):
+        return self.SelectedID
+
+    def SetSelectedID(self, id):
+        self.SelectedID = id
+
+    def GetItemData(self):
+        return self.data
+
+    def SetItemData(self, data):
+        self.data = data
+
+
+class Panel(wx.Panel):
+    def __init__(self, parent):
+        wx.Panel.__init__(self, parent, pos=wx.Point(5, 5))#,
+                          #size=wx.Size(280, 656))
+
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(InnerPanel(self), 1, wx.EXPAND|wx.GROW|wx.ALL, 5)
+
+        self.SetSizer(sizer)
+        sizer.Fit(self)
+
+        self.Layout()
+        self.Update()
+        self.SetAutoLayout(1)
+
+
+# Inner fold panel
+class InnerPanel(wx.Panel):
+    def __init__(self, parent):
+        wx.Panel.__init__(self, parent, pos=wx.Point(5, 5))#,
+                          #size=wx.Size(680, 656))
+
+        self.patients = []
+        self.first_image_selection = None
+        self.last_image_selection = None
+        self._init_ui()
+        self._bind_events()
+        self._bind_pubsubevt()
+
+    def _init_ui(self):
+        splitter = spl.MultiSplitterWindow(self, style=wx.SP_LIVE_UPDATE)
+        splitter.SetOrientation(wx.VERTICAL)
+        self.splitter = splitter
+
+        panel = wx.Panel(self)
+        self.btn_cancel = wx.Button(panel, wx.ID_CANCEL)
+        self.btn_ok = wx.Button(panel, wx.ID_OK, _("Import"))
+
+        btnsizer = wx.StdDialogButtonSizer()
+        btnsizer.AddButton(self.btn_ok)
+        btnsizer.AddButton(self.btn_cancel)
+        btnsizer.Realize()
+
+        self.combo_interval = wx.ComboBox(panel, -1, "", choices=const.IMPORT_INTERVAL,
+                                     style=wx.CB_DROPDOWN|wx.CB_READONLY)
+        self.combo_interval.SetSelection(0)
+
+        inner_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        inner_sizer.AddSizer(btnsizer, 0, wx.LEFT|wx.TOP, 5)
+        inner_sizer.Add(self.combo_interval, 0, wx.LEFT|wx.RIGHT|wx.TOP, 5)
+        panel.SetSizer(inner_sizer)
+        inner_sizer.Fit(panel)
+
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(splitter, 20, wx.EXPAND)
+        sizer.Add(panel, 0, wx.EXPAND|wx.LEFT, 90)
+
+        self.text_panel = TextPanel(splitter)
+        splitter.AppendWindow(self.text_panel, 250)
+
+        self.image_panel = ImagePanel(splitter)
+        splitter.AppendWindow(self.image_panel, 250)
+        
+        self.SetSizer(sizer)
+        sizer.Fit(self)
+
+        self.Layout()
+        self.Update()
+        self.SetAutoLayout(1)
+
+    def _bind_pubsubevt(self):
+        Publisher.subscribe(self.ShowBitmapPreview, "Load import bitmap panel")
+        Publisher.subscribe(self.GetSelectedImages ,"Selected Import Images")  
+
+    def ShowBitmapPreview(self, pubsub_evt):
+        data = pubsub_evt.data
+        #self.patients.extend(dicom_groups)
+        self.text_panel.Populate(data)
+
+    def GetSelectedImages(self, pubsub_evt):
+        self.first_image_selection = pubsub_evt.data[0]
+        self.last_image_selection = pubsub_evt.data[1]
+        
+    def _bind_events(self):
+        self.Bind(EVT_SELECT_SERIE, self.OnSelectSerie)
+        self.Bind(EVT_SELECT_SLICE, self.OnSelectSlice)
+        self.Bind(EVT_SELECT_PATIENT, self.OnSelectPatient)
+        self.btn_ok.Bind(wx.EVT_BUTTON, self.OnClickOk)
+        self.btn_cancel.Bind(wx.EVT_BUTTON, self.OnClickCancel)
+        self.text_panel.Bind(EVT_SELECT_SERIE_TEXT, self.OnDblClickTextPanel)
+
+    def OnSelectSerie(self, evt):
+        #patient_id, serie_number = evt.GetSelectID()
+        #self.text_panel.SelectSerie(evt.GetSelectID())
+        #for patient in self.patients:
+        #    if patient_id == patient.GetDicomSample().patient.id:
+        #        for group in patient.GetGroups():
+        #            if serie_number == group.GetDicomSample().acquisition.serie_number:
+        #                self.image_panel.SetSerie(group)
+
+        pass
+
+
+
+    def OnSelectSlice(self, evt):
+        pass
+
+    def OnSelectPatient(self, evt):
+        pass
+
+    def OnDblClickTextPanel(self, evt):
+        group = evt.GetItemData()
+        self.LoadDicom(group)
+
+    def OnClickOk(self, evt):
+        parm = dlg.ImportBitmapParameters()
+        parm.SetInterval(self.combo_interval.GetSelection())
+        parm.ShowModal()
+
+        group = self.text_panel.GetSelection()
+        if group:
+            self.LoadDicom(group)
+
+    def OnClickCancel(self, evt):
+        Publisher.sendMessage("Cancel DICOM load")
+
+    def LoadDicom(self, group):
+        #interval = self.combo_interval.GetSelection()
+        #if not isinstance(group, dcm.DicomGroup):
+        #    group = max(group.GetGroups(), key=lambda g: g.nslices)
+        
+        #slice_amont = group.nslices
+        #if (self.first_image_selection != None) and (self.first_image_selection != self.last_image_selection):
+        #    slice_amont = (self.last_image_selection) - self.first_image_selection
+        #    slice_amont += 1
+        #    if slice_amont == 0:
+        #        slice_amont = group.nslices
+
+        #nslices_result = slice_amont / (interval + 1)
+        #if (nslices_result > 1):
+        #    Publisher.sendMessage('Open DICOM group', (group, interval, 
+        #                            [self.first_image_selection, self.last_image_selection]))
+        #else:
+        #    dlg.MissingFilesForReconstruction()
+        pass
+
+
+class TextPanel(wx.Panel):
+    def __init__(self, parent):
+        wx.Panel.__init__(self, parent, -1)
+
+        self._selected_by_user = True
+        self.idserie_treeitem = {}
+        self.treeitem_idpatient = {}
+
+        self.__init_gui()
+        self.__bind_events_wx()
+        self.__bind_pubsub_evt()
+
+    def __bind_pubsub_evt(self):
+        Publisher.subscribe(self.SelectSeries, 'Select series in import panel')
+
+    def __bind_events_wx(self):
+        self.Bind(wx.EVT_SIZE, self.OnSize)
+
+    def __init_gui(self):
+        tree = gizmos.TreeListCtrl(self, -1, style =
+                                   wx.TR_DEFAULT_STYLE
+                                   | wx.TR_HIDE_ROOT
+                                   | wx.TR_ROW_LINES
+                                   | wx.TR_COLUMN_LINES
+                                   | wx.TR_FULL_ROW_HIGHLIGHT
+                                   | wx.TR_SINGLE
+                                   | wx.TR_HIDE_ROOT
+                                   )
+
+
+        tree.AddColumn(_("Path"))
+        tree.AddColumn(_("Type"))
+        tree.AddColumn(_("Width x Height"))
+
+
+        tree.SetMainColumn(0)
+        tree.SetColumnWidth(0, 880)
+        tree.SetColumnWidth(1, 60)
+        tree.SetColumnWidth(2, 130)
+
+        self.root = tree.AddRoot(_("InVesalius Database"))
+        self.tree = tree
+
+    def SelectSeries(self, pubsub_evt):
+        group_index = pubsub_evt.data
+
+    def Populate(self, data):
+        tree = self.tree
+        for value in data:
+            parent = tree.AppendItem(self.root, value[0])
+            self.tree.SetItemText(parent, value[2], 1)
+            self.tree.SetItemText(parent, value[5], 2)
+
+        tree.Expand(self.root)
+        #tree.SelectItem(parent_select)
+        tree.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnActivate)
+        tree.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged)
+
+        Publisher.sendMessage('Load bitmap into import panel', data)
+
+
+    def OnSelChanged(self, evt):
+        item = self.tree.GetSelection()
+        if self._selected_by_user:
+            group = self.tree.GetItemPyData(item)
+            if isinstance(group, dcm.DicomGroup):
+                Publisher.sendMessage('Load group into import panel',
+                                            group)
+
+            elif isinstance(group, dcm.PatientGroup):
+                id = group.GetDicomSample().patient.id
+                my_evt = SelectEvent(myEVT_SELECT_PATIENT, self.GetId())
+                my_evt.SetSelectedID(id)
+                self.GetEventHandler().ProcessEvent(my_evt)
+
+                Publisher.sendMessage('Load bitmap into import panel',
+
+                                            group)
+        else:
+            parent_id = self.tree.GetItemParent(item)
+            self.tree.Expand(parent_id)
+        evt.Skip()
+
+    def OnActivate(self, evt):
+        item = evt.GetItem()
+        group = self.tree.GetItemPyData(item)
+        my_evt = SelectEvent(myEVT_SELECT_SERIE_TEXT, self.GetId())
+        my_evt.SetItemData(group)
+        self.GetEventHandler().ProcessEvent(my_evt)
+
+    def OnSize(self, evt):
+        self.tree.SetSize(self.GetSize())
+
+    def SelectSerie(self, serie):
+        self._selected_by_user = False
+        item = self.idserie_treeitem[serie]
+        self.tree.SelectItem(item)
+        self._selected_by_user = True
+
+    def GetSelection(self):
+        """Get selected item"""
+        item = self.tree.GetSelection()
+        group = self.tree.GetItemPyData(item)
+        return group
+
+
+class ImagePanel(wx.Panel):
+    def __init__(self, parent):
+        wx.Panel.__init__(self, parent, -1)
+        self._init_ui()
+        self._bind_events()
+
+    def _init_ui(self):
+        splitter = spl.MultiSplitterWindow(self, style=wx.SP_LIVE_UPDATE)
+        splitter.SetOrientation(wx.HORIZONTAL)
+        self.splitter = splitter
+
+        splitter.ContainingSizer = wx.BoxSizer(wx.HORIZONTAL)
+
+        sizer = wx.BoxSizer(wx.HORIZONTAL)
+        sizer.Add(splitter, 1, wx.EXPAND)
+        self.SetSizer(sizer)
+
+        self.text_panel = SeriesPanel(splitter)
+        splitter.AppendWindow(self.text_panel, 600)
+
+        self.image_panel = SlicePanel(splitter)
+        splitter.AppendWindow(self.image_panel, 250)
+
+        self.SetSizer(sizer)
+        sizer.Fit(self)
+
+        self.Layout()
+        self.Update()
+        self.SetAutoLayout(1)
+
+    def _bind_events(self):
+        self.text_panel.Bind(EVT_SELECT_SERIE, self.OnSelectSerie)
+        self.text_panel.Bind(EVT_SELECT_SLICE, self.OnSelectSlice)
+
+    def OnSelectSerie(self, evt):
+        evt.Skip()
+
+    def OnSelectSlice(self, evt):
+        self.image_panel.bitmap_preview.ShowSlice(evt.GetSelectID())
+        evt.Skip()
+
+    def SetSerie(self, serie):
+        self.image_panel.bitmap_preview.SetDicomGroup(serie)
+
+
+class SeriesPanel(wx.Panel):
+    def __init__(self, parent):
+        wx.Panel.__init__(self, parent, -1)
+        #self.SetBackgroundColour((0,0,0))
+
+        self.thumbnail_preview = bpp.BitmapPreviewSeries(self)
+        #self.bitmap_preview = bpp.BitmapPreviewSlice(self)
+        #self.bitmap_preview.Show(0)
+        
+
+        self.sizer = wx.BoxSizer(wx.HORIZONTAL)
+        self.sizer.Add(self.thumbnail_preview, 1, wx.EXPAND | wx.ALL, 5)
+        #self.sizer.Add(self.bitmap_preview, 1, wx.EXPAND | wx.ALL, 5)
+        self.sizer.Fit(self)
+
+        self.SetSizer(self.sizer)
+
+        self.Layout()
+        self.Update()
+        self.SetAutoLayout(1)
+
+        self.__bind_evt()
+        self._bind_gui_evt()
+
+    def __bind_evt(self):
+        #Publisher.subscribe(self.ShowDicomSeries, 'Load bitmap preview')
+        #Publisher.subscribe(self.SetDicomSeries, 'Load group into import panel')
+        Publisher.subscribe(self.SetBitmapFiles, 'Load bitmap into import panel')
+
+    def _bind_gui_evt(self):
+        self.thumbnail_preview.Bind(bpp.EVT_CLICK_SERIE, self.OnSelectSerie)
+        #self.bitmap_preview.Bind(bpp.EVT_CLICK_SLICE, self.OnSelectSlice)
+
+    #def SetDicomSeries(self, pubsub_evt):
+    #    group = pubsub_evt.data
+    #    self.bitmap_preview.SetDicomGroup(group)
+    #    self.bitmap_preview.Show(1)
+    #    self.thumbnail_preview.Show(0)
+    #    self.sizer.Layout()
+    #    self.Update()
+
+    def GetSelectedImagesRange(self):
+        return [self.bitmap_preview.first_selected, self.dicom_preview_last_selection]
+
+    def SetBitmapFiles(self, pubsub_evt):
+
+
+        bitmap = pubsub_evt.data
+        #self.bitmap_preview.Show(0)
+        self.thumbnail_preview.Show(1)
+
+        self.thumbnail_preview.SetBitmapFiles(bitmap)
+        #self.bitmap_preview.SetPatientGroups(patient)
+
+        self.Update()
+
+    def OnSelectSerie(self, evt):
+        data = evt.GetItemData()
+
+        my_evt = SelectEvent(myEVT_SELECT_SERIE, self.GetId())
+        my_evt.SetSelectedID(evt.GetSelectID())
+        my_evt.SetItemData(evt.GetItemData())
+        self.GetEventHandler().ProcessEvent(my_evt)
+
+        #self.bitmap_preview.SetDicomGroup(data)
+        #self.bitmap_preview.Show(1)
+        #self.thumbnail_preview.Show(0)
+        self.sizer.Layout()
+        self.Show()
+        self.Update()
+
+    def OnSelectSlice(self, evt):
+        my_evt = SelectEvent(myEVT_SELECT_SLICE, self.GetId())
+        my_evt.SetSelectedID(evt.GetSelectID())
+        my_evt.SetItemData(evt.GetItemData())
+        self.GetEventHandler().ProcessEvent(my_evt)
+
+
+    #def ShowDicomSeries(self, pubsub_evt):
+    #    patient = pubsub_evt.data
+    #    if isinstance(patient, dcm.PatientGroup):
+    #        self.thumbnail_preview.SetPatientGroups(patient)
+    #        self.bitmap_preview.SetPatientGroups(patient)
+
+
+class SlicePanel(wx.Panel):
+    def __init__(self, parent):
+        wx.Panel.__init__(self, parent, -1)
+        self.__init_gui()
+        self.__bind_evt()
+
+    def __bind_evt(self):
+        #Publisher.subscribe(self.ShowDicomSeries, 'Load bitmap preview')
+        #Publisher.subscribe(self.SetDicomSeries, 'Load group into import panel')
+        Publisher.subscribe(self.SetBitmapFiles, 'Load bitmap into import panel')
+
+    def __init_gui(self):
+        self.SetBackgroundColour((255,255,255))
+        self.bitmap_preview = bpp.SingleImagePreview(self)
+
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        sizer.Add(self.bitmap_preview, 1, wx.GROW|wx.EXPAND)
+        sizer.Fit(self)
+        self.SetSizer(sizer)
+        self.Layout()
+        self.Update()
+        self.SetAutoLayout(1)
+        self.sizer = sizer
+
+    def SetBitmapFiles(self, pubsub_evt):
+        data = pubsub_evt.data
+        self.bitmap_preview.SetBitmapFiles(data)
+        self.sizer.Layout()
+        self.Update()
+
+    #def SetDicomSeries(self, evt):
+    #    group = evt.data
+    #    self.bitmap_preview.SetDicomGroup(group)
+    #    self.sizer.Layout()
+    #    self.Update()
+
+    #def ShowDicomSeries(self, pubsub_evt):
+    #    patient = pubsub_evt.data
+    #    group = patient.GetGroups()[0]
+    #    self.bitmap_preview.SetDicomGroup(group)
+    #    self.sizer.Layout()
+    #    self.Update()
+
@@ -524,6 +524,7 @@ class MaskProperties(wx.Panel):
         self.bind_evt_gradient = False
         self.gradient.SetMinValue(thresh_min)
         self.gradient.SetMaxValue(thresh_max)
+        print ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>", thresh_min, thresh_max
         self.bind_evt_gradient = True
         thresh = (thresh_min, thresh_max)
         if thresh in Project().threshold_modes.values():
@@ -73,12 +73,13 @@ class Presets():
     def UpdateThresholdModes(self, evt):
         thresh_min, thresh_max = evt.data
-        
         presets_list = (self.thresh_ct, self.thresh_mri)
         for presets in presets_list:
             for key in presets:
                 (t_min, t_max) = presets[key]
+
+
                 if (t_min is None) or (t_max is None): # setting custom preset
                     t_min = thresh_min
                     t_max = thresh_max
@@ -93,7 +94,7 @@ class Presets():
                     t_min = thresh_min
                 if (t_max < thresh_min):
                     t_max = thresh_max
-                    
+
                 presets[key] = (t_min, t_max)
         Publisher.sendMessage('Update threshold limits', (thresh_min,     
@@ -0,0 +1,389 @@
+#--------------------------------------------------------------------------
+# Software:     InVesalius - Software de Reconstrucao 3D de Imagens Medicas
+# Copyright:    (C) 2001  Centro de Pesquisas Renato Archer
+# Homepage:     http://www.softwarepublico.gov.br
+# Contact:      invesalius@cti.gov.br
+# License:      GNU - GPL 2 (LICENSE.txt/LICENCA.txt)
+#--------------------------------------------------------------------------
+#    Este programa e software livre; voce pode redistribui-lo e/ou
+#    modifica-lo sob os termos da Licenca Publica Geral GNU, conforme
+#    publicada pela Free Software Foundation; de acordo com a versao 2
+#    da Licenca.
+#
+#    Este programa eh distribuido na expectativa de ser util, mas SEM
+#    QUALQUER GARANTIA; sem mesmo a garantia implicita de
+#    COMERCIALIZACAO ou de ADEQUACAO A QUALQUER PROPOSITO EM
+#    PARTICULAR. Consulte a Licenca Publica Geral GNU para obter mais
+#    detalhes.
+#--------------------------------------------------------------------------
+import os
+import Queue
+import threading
+import tempfile
+import sys
+import vtk
+import re
+import constants as const
+import wx
+
+from wx.lib.pubsub import pub as Publisher
+from multiprocessing import cpu_count
+
+from vtk.util import numpy_support
+from scipy import misc
+import numpy
+import imghdr
+
+from data import converters
+
+#flag to control vtk error in read files
+no_error = True 
+vtk_error = False
+
+class Singleton:
+
+    def __init__(self,klass):
+        self.klass = klass
+        self.instance = None
+            
+    def __call__(self,*args,**kwds):
+        if self.instance == None:
+            self.instance = self.klass(*args,**kwds)
+        return self.instance
+
+@Singleton
+class BitmapData:
+
+    def __init__(self):
+        self.data = None
+
+    def GetData(self):
+        return self.data
+
+    def SetData(self, data):
+        self.data = data
+
+    def GetOnlyBitmapPath(self):
+        paths = [item[0] for item in self.data]
+        return paths
+
+    def GetFirstBitmapSize(self):
+        return (self.data[0][3], self.data[0][4])
+
+    def IsAllBitmapSameSize(self):
+        sizes = [item[5] for item in self.data]
+
+        k = {}
+        for v in sizes:
+            k[v] = ''
+
+        if len(k.keys()) > 1:
+            return False
+        else:
+            return True
+
+    def GetFirstPixelSize(self):
+        
+        path = self.data[0][0] 
+        size = ReadBitmap(path).dtype.itemsize * 8
+        
+        return size
+
+
+
+class BitmapFiles:
+
+    def __init__(self):
+        self.bitmapfiles = []
+
+    def Add(self, bmp):
+        self.bitmapfiles.append(bmp)
+
+    def Sort(self, x):
+
+        c_re = re.compile('\d+')
+
+        if len(c_re.findall(x[0])) > 0:
+            return c_re.findall(x[0])[-1] 
+        else:
+            return '0'
+
+    def GetValues(self):
+        bmpfile = self.bitmapfiles
+        bmpfile.sort(key = self.Sort)
+
+        bmp_data = BitmapData()
+        bmp_data.data = bmpfile
+
+        return bmpfile
+
+class LoadBitmap:
+
+    def __init__(self, bmp_file, filepath):
+        self.bmp_file = bmp_file
+        if sys.platform == 'win32':
+            self.filepath = filepath.encode(utils.get_system_encoding())
+        else:
+            self.filepath = filepath
+        
+        self.run()
+    
+    def run(self):
+        global vtk_error
+
+        #----- verify extension ------------------
+        #ex = self.filepath.split('.')[-1]
+        extension = VerifyDataType(self.filepath)
+
+        file_name = self.filepath.split(os.path.sep)[-1]
+
+        #if extension == 'bmp':
+        #    reader = vtk.vtkBMPReader()
+        n_array = ReadBitmap(self.filepath)
+      
+        if not(isinstance(n_array, numpy.ndarray)):
+            return False
+            
+        image = converters.to_vtk(n_array, spacing=(1,1,1),\
+                slice_number=1, orientation="AXIAL")
+
+
+        #reader.SetFileName(self.filepath)
+        #reader.Update()
+
+        dim = image.GetDimensions()
+        x = dim[0]
+        y = dim[1]
+
+        img = vtk.vtkImageResample()
+        img.SetInputData(image)
+        img.SetAxisMagnificationFactor ( 0, 0.25 )
+        img.SetAxisMagnificationFactor ( 1, 0.25 )
+        img.SetAxisMagnificationFactor ( 2, 1 )    
+        img.Update()
+
+        tp = img.GetOutput().GetScalarTypeAsString()
+
+        image_copy = vtk.vtkImageData()
+        image_copy.DeepCopy(img.GetOutput())
+        
+        thumbnail_path = tempfile.mktemp()
+
+        write_png = vtk.vtkPNGWriter()
+        write_png.SetInputConnection(img.GetOutputPort())
+        write_png.AddObserver("WarningEvent", VtkErrorPNGWriter)
+        write_png.SetFileName(thumbnail_path)
+        write_png.Write()
+
+        if vtk_error:
+            img = vtk.vtkImageCast()
+            img.SetInputData(image_copy)
+            img.SetOutputScalarTypeToUnsignedShort()
+            #img.SetClampOverflow(1)
+            img.Update()
+
+            write_png = vtk.vtkPNGWriter()
+            write_png.SetInputConnection(img.GetOutputPort())
+            write_png.SetFileName(thumbnail_path)
+            write_png.Write()
+    
+            vtk_error = False
+
+        id = wx.NewId()
+
+        bmp_item = [self.filepath, thumbnail_path, extension, x, y,\
+                                str(x) + ' x ' + str(y), file_name, id]
+        self.bmp_file.Add(bmp_item)
+
+
+def yGetBitmaps(directory, recursive=True, gui=True):
+    """
+    Return all full paths to DICOM files inside given directory.
+    """
+    nfiles = 0
+    # Find total number of files
+    if recursive:
+        for dirpath, dirnames, filenames in os.walk(directory):
+            nfiles += len(filenames)
+    else:
+        dirpath, dirnames, filenames = os.walk(directory)
+        nfiles = len(filenames)
+
+
+    counter = 0
+    bmp_file = BitmapFiles()
+
+    # Retrieve only TIFF, BMP, JPEG and PNG files
+    if recursive:
+        for dirpath, dirnames, filenames in os.walk(directory):
+            for name in filenames:
+                filepath = os.path.join(dirpath, name)
+                counter += 1
+                if gui:
+                    yield (counter,nfiles)
+                #LoadDicom(grouper, filepath)
+                LoadBitmap(bmp_file, filepath)
+    else:
+        dirpath, dirnames, filenames = os.walk(directory)
+        for name in filenames:
+            filepath = str(os.path.join(dirpath, name))
+            counter += 1
+            if gui:
+                yield (counter,nfiles)
+            #q.put(filepath)
+
+    #for t in threads:
+    #    q.put(0)
+
+    #for t in threads:
+    #    t.join()
+
+    #TODO: Is this commented update necessary?
+    #grouper.Update()
+    yield bmp_file.GetValues()
+
+
+class ProgressBitmapReader:
+    def __init__(self):
+        Publisher.subscribe(self.CancelLoad, "Cancel bitmap load")
+
+    def CancelLoad(self, evt_pubsub):
+        self.running = False
+        self.stoped = True
+
+    def SetWindowEvent(self, frame):
+        self.frame = frame          
+
+    def SetDirectoryPath(self, path,recursive=True):
+        self.running = True
+        self.stoped = False
+        self.GetBitmaps(path,recursive)
+
+    def UpdateLoadFileProgress(self,cont_progress):
+        Publisher.sendMessage("Update bitmap load", cont_progress)
+
+    def EndLoadFile(self, bitmap_list):
+        Publisher.sendMessage("End bitmap load", bitmap_list)
+
+    def GetBitmaps(self, path, recursive):
+
+        #if not const.VTK_WARNING:
+        #    log_path = os.path.join(const.LOG_FOLDER, 'vtkoutput.txt')
+        #    fow = vtk.vtkFileOutputWindow()
+        #    fow.SetFileName(log_path)
+        #    ow = vtk.vtkOutputWindow()
+        #    ow.SetInstance(fow)
+
+        y = yGetBitmaps(path, recursive)
+        for value_progress in y:
+            if not self.running:
+                break
+            if isinstance(value_progress, tuple):
+                self.UpdateLoadFileProgress(value_progress)
+            else:
+                self.EndLoadFile(value_progress)
+
+        #Is necessary in the case user cancel
+        #the load, ensure that dicomdialog is closed
+        if(self.stoped):
+            self.UpdateLoadFileProgress(None)
+            self.stoped = False   
+
+def VtkErrorPNGWriter(obj, f):
+    global vtk_error
+    vtk_error = True
+
+def ScipyRead(filepath):
+    try:
+        r = misc.imread(filepath, flatten=True)
+        dt = r.dtype 
+        
+        if  dt == "float" or dt == "float16"\
+                          or dt == "float32" or dt == "float64":   
+            shift=-r.max()/2
+            simage = numpy.zeros_like(r, dtype='int16')
+            simage[:] = r.astype('int32') + shift
+
+            return simage
+        else:
+            return r
+    except(IOError):
+        return False
+
+def VtkRead(filepath, t):
+    
+    global no_error
+
+    if t == "bmp":
+        reader = vtk.vtkBMPReader()
+
+    elif t == "tiff" or t == "tif":
+        reader = vtk.vtkTIFFReader()
+
+    elif t == "png":
+        reader = vtk.vtkPNGReader()
+    
+    elif t == "jpeg" or t == "jpg":
+        reader = vtk.vtkJPEGReader()
+
+    else:
+        return False
+
+    reader.AddObserver("ErrorEvent", VtkErrorToPy)
+    reader.SetFileName(filepath)
+    reader.Update()
+    
+    if no_error:
+        image = reader.GetOutput()
+        dim = image.GetDimensions()
+       
+        if reader.GetNumberOfScalarComponents() > 1:
+            luminanceFilter = vtk.vtkImageLuminance()
+            luminanceFilter.SetInputData(image)
+            luminanceFilter.Update()
+
+            image = vtk.vtkImageData()
+            image.DeepCopy(luminanceFilter.GetOutput())
+
+        img_array = numpy_support.vtk_to_numpy(image.GetPointData().GetScalars())
+        img_array.shape = (dim[1], dim[0])
+
+        return img_array
+    else:
+        no_error = True
+        return False
+
+
+def ReadBitmap(filepath): 
+    
+    t = VerifyDataType(filepath)
+
+    if t == False:
+        return False
+
+    img_array = VtkRead(filepath, t)
+    
+    if not(isinstance(img_array, numpy.ndarray)):
+        
+        no_error = True
+        
+        img_array = ScipyRead(filepath)
+        
+        if not(isinstance(img_array, numpy.ndarray)):
+            return False
+
+    return img_array
+            
+
+def VtkErrorToPy(obj, evt):
+    global no_error
+    no_error = False
+
+
+def VerifyDataType(filepath):
+    try:
+        t = imghdr.what(filepath)
+        return t
+    except IOError:
+        return False
+
	@@ -452,7 +452,7 @@ VTK_WARNING = 0		@@ -452,7 +452,7 @@ VTK_WARNING = 0
452	[ID_DICOM_IMPORT, ID_PROJECT_OPEN, ID_PROJECT_SAVE_AS, ID_PROJECT_SAVE,	452	[ID_DICOM_IMPORT, ID_PROJECT_OPEN, ID_PROJECT_SAVE_AS, ID_PROJECT_SAVE,
453	ID_PROJECT_CLOSE, ID_PROJECT_INFO, ID_SAVE_SCREENSHOT, ID_DICOM_LOAD_NET,	453	ID_PROJECT_CLOSE, ID_PROJECT_INFO, ID_SAVE_SCREENSHOT, ID_DICOM_LOAD_NET,
454	ID_PRINT_SCREENSHOT, ID_IMPORT_OTHERS_FILES, ID_ANALYZE_IMPORT, ID_PREFERENCES,	454	ID_PRINT_SCREENSHOT, ID_IMPORT_OTHERS_FILES, ID_ANALYZE_IMPORT, ID_PREFERENCES,
455	-ID_DICOM_NETWORK] = [wx.NewId() for number in range(13)]	455	+ID_DICOM_NETWORK, ID_TIFF_JPG_PNG] = [wx.NewId() for number in range(14)]
456	ID_EXIT = wx.ID_EXIT	456	ID_EXIT = wx.ID_EXIT
457	ID_ABOUT = wx.ID_ABOUT	457	ID_ABOUT = wx.ID_ABOUT
458		458
	@@ -35,8 +35,10 @@ import project as prj		@@ -35,8 +35,10 @@ import project as prj
35	import reader.analyze_reader as analyze	35	import reader.analyze_reader as analyze
36	import reader.dicom_grouper as dg	36	import reader.dicom_grouper as dg
37	import reader.dicom_reader as dcm	37	import reader.dicom_reader as dcm
		38	+import reader.bitmap_reader as bmp
38	import session as ses	39	import session as ses
39		40
		41	+
40	import utils	42	import utils
41	import gui.dialogs as dialogs	43	import gui.dialogs as dialogs
42	import subprocess	44	import subprocess
	@@ -74,13 +76,20 @@ class Controller():		@@ -74,13 +76,20 @@ class Controller():
74	'Save raycasting preset')	76	'Save raycasting preset')
75	Publisher.subscribe(self.OnOpenDicomGroup,	77	Publisher.subscribe(self.OnOpenDicomGroup,
76	'Open DICOM group')	78	'Open DICOM group')
		79	+ Publisher.subscribe(self.OnOpenBitmapFiles,
		80	+ 'Open bitmap files')
77	Publisher.subscribe(self.Progress, "Update dicom load")	81	Publisher.subscribe(self.Progress, "Update dicom load")
		82	+ Publisher.subscribe(self.Progress, "Update bitmap load")
78	Publisher.subscribe(self.OnLoadImportPanel, "End dicom load")	83	Publisher.subscribe(self.OnLoadImportPanel, "End dicom load")
		84	+ Publisher.subscribe(self.OnLoadImportBitmapPanel, "End bitmap load")
79	Publisher.subscribe(self.OnCancelImport, 'Cancel DICOM load')	85	Publisher.subscribe(self.OnCancelImport, 'Cancel DICOM load')
		86	+ Publisher.subscribe(self.OnCancelImportBitmap, 'Cancel bitmap load')
		87	+
80	Publisher.subscribe(self.OnShowDialogCloseProject, 'Close Project')	88	Publisher.subscribe(self.OnShowDialogCloseProject, 'Close Project')
81	Publisher.subscribe(self.OnOpenProject, 'Open project')	89	Publisher.subscribe(self.OnOpenProject, 'Open project')
82	Publisher.subscribe(self.OnOpenRecentProject, 'Open recent project')	90	Publisher.subscribe(self.OnOpenRecentProject, 'Open recent project')
83	Publisher.subscribe(self.OnShowAnalyzeFile, 'Show analyze dialog')	91	Publisher.subscribe(self.OnShowAnalyzeFile, 'Show analyze dialog')
		92	+ Publisher.subscribe(self.OnShowBitmapFile, 'Show bitmap dialog')
84		93
85	Publisher.subscribe(self.ShowBooleanOpDialog, 'Show boolean dialog')	94	Publisher.subscribe(self.ShowBooleanOpDialog, 'Show boolean dialog')
86		95
	@@ -92,7 +101,9 @@ class Controller():		@@ -92,7 +101,9 @@ class Controller():
92	Publisher.sendMessage('Hide import panel')	101	Publisher.sendMessage('Hide import panel')
93		102
94		103
95	-	104	+ def OnCancelImportBitmap(self, pubsub_evt):
		105	+ #self.cancel_import = True
		106	+ Publisher.sendMessage('Hide import bitmap panel')
96		107
97	###########################	108	###########################
98	###########################	109	###########################
	@@ -119,9 +130,35 @@ class Controller():		@@ -119,9 +130,35 @@ class Controller():
119	self.LoadProject()	130	self.LoadProject()
120	Publisher.sendMessage("Enable state project", True)	131	Publisher.sendMessage("Enable state project", True)
121		132
122	-	133	+ def OnShowBitmapFile(self, pubsub_evt):
		134	+ self.ShowDialogImportBitmapFile()
123	###########################	135	###########################
124		136
		137	+ def ShowDialogImportBitmapFile(self):
		138	+ # Offer to save current project if necessary
		139	+ session = ses.Session()
		140	+ st = session.project_status
		141	+ if (st == const.PROJ_NEW) or (st == const.PROJ_CHANGE):
		142	+ filename = session.project_path[1]
		143	+ answer = dialog.SaveChangesDialog2(filename)
		144	+ if answer:
		145	+ self.ShowDialogSaveProject()
		146	+ self.CloseProject()
		147	+ #Publisher.sendMessage("Enable state project", False)
		148	+ Publisher.sendMessage('Set project name')
		149	+ Publisher.sendMessage("Stop Config Recording")
		150	+ Publisher.sendMessage("Set slice interaction style", const.STATE_DEFAULT)
		151	+
		152	+ # Import TIFF, BMP, JPEG or PNG
		153	+ dirpath = dialog.ShowImportBitmapDirDialog()
		154	+
		155	+ if dirpath and not os.listdir(dirpath):
		156	+ dialog.ImportEmptyDirectory(dirpath)
		157	+ elif dirpath:
		158	+ self.StartImportBitmapPanel(dirpath)
		159	+ # Publisher.sendMessage("Load data to import panel", dirpath)
		160	+
		161	+
125	def ShowDialogImportDirectory(self):	162	def ShowDialogImportDirectory(self):
126	# Offer to save current project if necessary	163	# Offer to save current project if necessary
127	session = ses.Session()	164	session = ses.Session()
	@@ -291,6 +328,12 @@ class Controller():		@@ -291,6 +328,12 @@ class Controller():
291		328
292	###########################	329	###########################
293		330
		331	+ def StartImportBitmapPanel(self, path):
		332	+ # retrieve DICOM files splited into groups
		333	+ reader = bmp.ProgressBitmapReader()
		334	+ reader.SetWindowEvent(self.frame)
		335	+ reader.SetDirectoryPath(path)
		336	+ Publisher.sendMessage('End busy cursor')
294		337
295	def StartImportPanel(self, path):	338	def StartImportPanel(self, path):
296		339
	@@ -324,6 +367,26 @@ class Controller():		@@ -324,6 +367,26 @@ class Controller():
324	Publisher.sendMessage('Show import panel')	367	Publisher.sendMessage('Show import panel')
325	Publisher.sendMessage("Show import panel in frame")	368	Publisher.sendMessage("Show import panel in frame")
326		369
		370	+ def OnLoadImportBitmapPanel(self, evt):
		371	+ data = evt.data
		372	+ ok = self.LoadImportBitmapPanel(data)
		373	+ if ok:
		374	+ Publisher.sendMessage('Show import bitmap panel in frame')
		375	+ #Publisher.sendMessage("Show import panel in frame")
		376	+
		377	+ def LoadImportBitmapPanel(self, data):
		378	+ #if patient_series and isinstance(patient_series, list):
		379	+ #Publisher.sendMessage("Load import panel", patient_series)
		380	+ #first_patient = patient_series[0]
		381	+ #Publisher.sendMessage("Load bitmap preview", first_patient)
		382	+ if data:
		383	+ Publisher.sendMessage("Load import bitmap panel", data)
		384	+
		385	+ return True
		386	+ else:
		387	+ dialog.ImportInvalidFiles()
		388	+ return False
		389	+
327		390
328	def LoadImportPanel(self, patient_series):	391	def LoadImportPanel(self, patient_series):
329	if patient_series and isinstance(patient_series, list):	392	if patient_series and isinstance(patient_series, list):
	@@ -335,6 +398,9 @@ class Controller():		@@ -335,6 +398,9 @@ class Controller():
335	dialog.ImportInvalidFiles()	398	dialog.ImportInvalidFiles()
336	return False	399	return False
337		400
		401	+
		402	+ #----------- to import by command line ---------------------------------------------------
		403	+
338	def OnImportMedicalImages(self, pubsub_evt):	404	def OnImportMedicalImages(self, pubsub_evt):
339	directory = pubsub_evt.data	405	directory = pubsub_evt.data
340	self.ImportMedicalImages(directory)	406	self.ImportMedicalImages(directory)
	@@ -358,6 +424,8 @@ class Controller():		@@ -358,6 +424,8 @@ class Controller():
358	self.LoadProject()	424	self.LoadProject()
359	Publisher.sendMessage("Enable state project", True)	425	Publisher.sendMessage("Enable state project", True)
360		426
		427	+ #-------------------------------------------------------------------------------------
		428	+
361	def LoadProject(self):	429	def LoadProject(self):
362	proj = prj.Project()	430	proj = prj.Project()
363		431
	@@ -401,9 +469,13 @@ class Controller():		@@ -401,9 +469,13 @@ class Controller():
401	Publisher.sendMessage('Show mask', (mask_index, True))	469	Publisher.sendMessage('Show mask', (mask_index, True))
402	else:	470	else:
403	mask_name = const.MASK_NAME_PATTERN % (1,)	471	mask_name = const.MASK_NAME_PATTERN % (1,)
404	- thresh = const.THRESHOLD_RANGE
405	- colour = const.MASK_COLOUR[0]
406		472
		473	+ if proj.modality != "UNKNOWN":
		474	+ thresh = const.THRESHOLD_RANGE
		475	+ else:
		476	+ thresh = proj.threshold_range
		477	+
		478	+ colour = const.MASK_COLOUR[0]
407	Publisher.sendMessage('Create new mask',	479	Publisher.sendMessage('Create new mask',
408	(mask_name, thresh, colour))	480	(mask_name, thresh, colour))
409		481
	@@ -483,6 +555,138 @@ class Controller():		@@ -483,6 +555,138 @@ class Controller():
483	dirpath = session.CreateProject(filename)	555	dirpath = session.CreateProject(filename)
484	#proj.SavePlistProject(dirpath, filename)	556	#proj.SavePlistProject(dirpath, filename)
485		557
		558	+
		559	+ def CreateBitmapProject(self, bmp_data, rec_data, matrix, matrix_filename):
		560	+ name_to_const = {"AXIAL":const.AXIAL,
		561	+ "CORONAL":const.CORONAL,
		562	+ "SAGITTAL":const.SAGITAL}
		563	+
		564	+ name = rec_data[0]
		565	+ orientation = rec_data[1]
		566	+ sp_x = float(rec_data[2])
		567	+ sp_y = float(rec_data[3])
		568	+ sp_z = float(rec_data[4])
		569	+ interval = int(rec_data[5])
		570	+
		571	+ bits = bmp_data.GetFirstPixelSize()
		572	+ sx, sy = size = bmp_data.GetFirstBitmapSize()
		573	+
		574	+ proj = prj.Project()
		575	+ proj.name = name
		576	+ proj.modality = 'UNKNOWN'
		577	+ proj.SetAcquisitionModality(proj.modality)
		578	+ proj.matrix_shape = matrix.shape
		579	+ proj.matrix_dtype = matrix.dtype.name
		580	+ proj.matrix_filename = matrix_filename
		581	+ #proj.imagedata = imagedata
		582	+ #proj.dicom_sample = dicom
		583	+ proj.original_orientation =\
		584	+ name_to_const[orientation.upper()]
		585	+ proj.window = float(matrix.max())
		586	+ proj.level = float(matrix.max()/2)
		587	+
		588	+ proj.threshold_range = int(matrix.min()), int(matrix.max())
		589	+ #const.THRESHOLD_RANGE = proj.threshold_range
		590	+
		591	+ proj.spacing = self.Slice.spacing
		592	+
		593	+ ######
		594	+ session = ses.Session()
		595	+ filename = proj.name+".inv3"
		596	+
		597	+ filename = filename.replace("/", "") #Fix problem case other/Skull_DICOM
		598	+
		599	+ dirpath = session.CreateProject(filename)
		600	+
		601	+ def OnOpenBitmapFiles(self, pubsub_evt):
		602	+ rec_data = pubsub_evt.data
		603	+ bmp_data = bmp.BitmapData()
		604	+ matrix, matrix_filename = self.OpenBitmapFiles(bmp_data, rec_data)
		605	+
		606	+ self.CreateBitmapProject(bmp_data, rec_data, matrix, matrix_filename)
		607	+
		608	+ self.LoadProject()
		609	+ Publisher.sendMessage("Enable state project", True)
		610	+
		611	+
		612	+ def OpenBitmapFiles(self, bmp_data, rec_data):
		613	+
		614	+ if bmp_data.IsAllBitmapSameSize():
		615	+
		616	+ name = rec_data[0]
		617	+ orientation = rec_data[1]
		618	+ sp_x = float(rec_data[2])
		619	+ sp_y = float(rec_data[3])
		620	+ sp_z = float(rec_data[4])
		621	+ interval = int(rec_data[5])
		622	+
		623	+ interval += 1
		624	+
		625	+ filelist = bmp_data.GetOnlyBitmapPath()[::interval]
		626	+ bits = bmp_data.GetFirstPixelSize()
		627	+
		628	+ sx, sy = size = bmp_data.GetFirstBitmapSize()
		629	+ n_slices = len(filelist)
		630	+ resolution_percentage = utils.calculate_resizing_tofitmemory(int(sx), int(sy), n_slices, bits/8)
		631	+
		632	+ zspacing = sp_z * interval
		633	+ xyspacing = (sp_y, sp_x)
		634	+
		635	+ if resolution_percentage < 1.0:
		636	+
		637	+ re_dialog = dialog.ResizeImageDialog()
		638	+ re_dialog.SetValue(int(resolution_percentage*100))
		639	+ re_dialog_value = re_dialog.ShowModal()
		640	+ re_dialog.Close()
		641	+
		642	+ if re_dialog_value == wx.ID_OK:
		643	+ percentage = re_dialog.GetValue()
		644	+ resolution_percentage = percentage / 100.0
		645	+ else:
		646	+ return
		647	+
		648	+ xyspacing = xyspacing[0] / resolution_percentage, xyspacing[1] / resolution_percentage
		649	+
		650	+
		651	+
		652	+ self.matrix, scalar_range, self.filename = image_utils.bitmap2memmap(filelist, size,
		653	+ orientation, (sp_z, sp_y, sp_x),resolution_percentage)
		654	+
		655	+
		656	+ self.Slice = sl.Slice()
		657	+ self.Slice.matrix = self.matrix
		658	+ self.Slice.matrix_filename = self.filename
		659	+
		660	+ if orientation == 'AXIAL':
		661	+ self.Slice.spacing = xyspacing[0], xyspacing[1], zspacing
		662	+ elif orientation == 'CORONAL':
		663	+ self.Slice.spacing = xyspacing[0], zspacing, xyspacing[1]
		664	+ elif orientation == 'SAGITTAL':
		665	+ self.Slice.spacing = zspacing, xyspacing[1], xyspacing[0]
		666	+
		667	+ # 1(a): Fix gantry tilt, if any
		668	+ #tilt_value = dicom.acquisition.tilt
		669	+ #if (tilt_value) and (gui):
		670	+ # # Tell user gantry tilt and fix, according to answer
		671	+ # message = _("Fix gantry tilt applying the degrees below")
		672	+ # value = -1*tilt_value
		673	+ # tilt_value = dialog.ShowNumberDialog(message, value)
		674	+ # image_utils.FixGantryTilt(self.matrix, self.Slice.spacing, tilt_value)
		675	+ #elif (tilt_value) and not (gui):
		676	+ # tilt_value = -1*tilt_value
		677	+ # image_utils.FixGantryTilt(self.matrix, self.Slice.spacing, tilt_value)
		678	+
		679	+ self.Slice.window_level = float(self.matrix.max()/2)
		680	+ self.Slice.window_width = float(self.matrix.max())
		681	+
		682	+ scalar_range = int(self.matrix.min()), int(self.matrix.max())
		683	+ Publisher.sendMessage('Update threshold limits list', scalar_range)
		684	+
		685	+ return self.matrix, self.filename#, dicom
		686	+
		687	+ else:
		688	+ print "Error: All slices must be of the same size."
		689	+
486	def OnOpenDicomGroup(self, pubsub_evt):	690	def OnOpenDicomGroup(self, pubsub_evt):
487	group, interval, file_range = pubsub_evt.data	691	group, interval, file_range = pubsub_evt.data
488	matrix, matrix_filename, dicom = self.OpenDicomGroup(group, interval, file_range, gui=True)	692	matrix, matrix_filename, dicom = self.OpenDicomGroup(group, interval, file_range, gui=True)
	@@ -32,7 +32,9 @@ from vtk.util import numpy_support		@@ -32,7 +32,9 @@ from vtk.util import numpy_support
32		32
33	import constants as const	33	import constants as const
34	from data import vtk_utils	34	from data import vtk_utils
		35	+from reader import bitmap_reader
35	import utils	36	import utils
		37	+import converters
36		38
37	# TODO: Test cases which are originally in sagittal/coronal orientation	39	# TODO: Test cases which are originally in sagittal/coronal orientation
38	# and have gantry	40	# and have gantry
	@@ -416,6 +418,90 @@ class ImageCreator:		@@ -416,6 +418,90 @@ class ImageCreator:
416		418
417	return imagedata	419	return imagedata
418		420
		421	+def bitmap2memmap(files, slice_size, orientation, spacing, resolution_percentage):
		422	+ """
		423	+ From a list of dicom files it creates memmap file in the temp folder and
		424	+ returns it and its related filename.
		425	+ """
		426	+ message = _("Generating multiplanar visualization...")
		427	+ update_progress= vtk_utils.ShowProgress(len(files) - 1, dialog_type = "ProgressDialog")
		428	+
		429	+ temp_file = tempfile.mktemp()
		430	+
		431	+ if orientation == 'SAGITTAL':
		432	+ if resolution_percentage == 1.0:
		433	+ shape = slice_size[0], slice_size[1], len(files)
		434	+ else:
		435	+ shape = math.ceil(slice_size[0]*resolution_percentage),\
		436	+ math.ceil(slice_size[1]*resolution_percentage), len(files)
		437	+
		438	+ elif orientation == 'CORONAL':
		439	+ if resolution_percentage == 1.0:
		440	+ shape = slice_size[1], len(files), slice_size[0]
		441	+ else:
		442	+ shape = math.ceil(slice_size[1]*resolution_percentage), len(files),\
		443	+ math.ceil(slice_size[0]*resolution_percentage)
		444	+ else:
		445	+ if resolution_percentage == 1.0:
		446	+ shape = len(files), slice_size[1], slice_size[0]
		447	+ else:
		448	+ shape = len(files), math.ceil(slice_size[1]*resolution_percentage),\
		449	+ math.ceil(slice_size[0]*resolution_percentage)
		450	+
		451	+ matrix = numpy.memmap(temp_file, mode='w+', dtype='int16', shape=shape)
		452	+ cont = 0
		453	+ max_scalar = None
		454	+ min_scalar = None
		455	+
		456	+ for n, f in enumerate(files):
		457	+ image_as_array = bitmap_reader.ReadBitmap(f)
		458	+
		459	+ image = converters.to_vtk(image_as_array, spacing=spacing,\
		460	+ slice_number=1, orientation=orientation.upper())
		461	+
		462	+ if resolution_percentage != 1.0:
		463	+
		464	+
		465	+ image_resized = ResampleImage2D(image, px=None, py=None,\
		466	+ resolution_percentage = resolution_percentage, update_progress = None)
		467	+
		468	+ image = image_resized
		469	+
		470	+ min_aux, max_aux = image.GetScalarRange()
		471	+ if min_scalar is None or min_aux < min_scalar:
		472	+ min_scalar = min_aux
		473	+
		474	+ if max_scalar is None or max_aux > max_scalar:
		475	+ max_scalar = max_aux
		476	+
		477	+ array = numpy_support.vtk_to_numpy(image.GetPointData().GetScalars())
		478	+ array = array.astype("int16")
		479	+
		480	+ array = image_as_array
		481	+
		482	+ if orientation == 'CORONAL':
		483	+ array.shape = matrix.shape[0], matrix.shape[2]
		484	+ matrix[:, n, :] = array
		485	+ elif orientation == 'SAGITTAL':
		486	+ array.shape = matrix.shape[0], matrix.shape[1]
		487	+ # TODO: Verify if it's necessary to add the slices swapped only in
		488	+ # sagittal rmi or only in # Rasiane's case or is necessary in all
		489	+ # sagittal cases.
		490	+ matrix[:, :, n] = array
		491	+ else:
		492	+ print array.shape, matrix.shape
		493	+ array.shape = matrix.shape[1], matrix.shape[2]
		494	+ matrix[n] = array
		495	+ update_progress(cont,message)
		496	+ cont += 1
		497	+
		498	+ matrix.flush()
		499	+ scalar_range = min_scalar, max_scalar
		500	+
		501	+ return matrix, scalar_range, temp_file
		502	+
		503	+
		504	+
419	def dcm2memmap(files, slice_size, orientation, resolution_percentage):	505	def dcm2memmap(files, slice_size, orientation, resolution_percentage):
420	"""	506	"""
421	From a list of dicom files it creates memmap file in the temp folder and	507	From a list of dicom files it creates memmap file in the temp folder and
	@@ -462,7 +548,6 @@ def dcm2memmap(files, slice_size, orientation, resolution_percentage):		@@ -462,7 +548,6 @@ def dcm2memmap(files, slice_size, orientation, resolution_percentage):
462	resolution_percentage = resolution_percentage, update_progress = None)	548	resolution_percentage = resolution_percentage, update_progress = None)
463		549
464	image = image_resized	550	image = image_resized
465	- print ">>>>>>>>>", image.GetDimensions()
466		551
467	min_aux, max_aux = image.GetScalarRange()	552	min_aux, max_aux = image.GetScalarRange()
468	if min_scalar is None or min_aux < min_scalar:	553	if min_scalar is None or min_aux < min_scalar:
	@@ -482,7 +567,6 @@ def dcm2memmap(files, slice_size, orientation, resolution_percentage):		@@ -482,7 +567,6 @@ def dcm2memmap(files, slice_size, orientation, resolution_percentage):
482	# sagittal cases.	567	# sagittal cases.
483	matrix[:, :, n] = array	568	matrix[:, :, n] = array
484	else:	569	else:
485	- print array.shape, matrix.shape
486	array.shape = matrix.shape[1], matrix.shape[2]	570	array.shape = matrix.shape[1], matrix.shape[2]
487	matrix[n] = array	571	matrix[n] = array
488	update_progress(cont,message)	572	update_progress(cont,message)
	@@ -39,6 +39,12 @@ from gui.widgets.clut_imagedata import CLUTImageDataWidget, EVT_CLUT_NODE_CHANGE		@@ -39,6 +39,12 @@ from gui.widgets.clut_imagedata import CLUTImageDataWidget, EVT_CLUT_NODE_CHANGE
39		39
40	import numpy as np	40	import numpy as np
41		41
		42	+try:
		43	+ from agw import floatspin as FS
		44	+except ImportError: # if it's not there locally, try the wxPython lib.
		45	+ import wx.lib.agw.floatspin as FS
		46	+
		47	+
42	class MaskEvent(wx.PyCommandEvent):	48	class MaskEvent(wx.PyCommandEvent):
43	def __init__(self , evtType, id, mask_index):	49	def __init__(self , evtType, id, mask_index):
44	wx.PyCommandEvent.__init__(self, evtType, id,)	50	wx.PyCommandEvent.__init__(self, evtType, id,)
	@@ -306,6 +312,48 @@ def ShowImportDirDialog():		@@ -306,6 +312,48 @@ def ShowImportDirDialog():
306	os.chdir(current_dir)	312	os.chdir(current_dir)
307	return path	313	return path
308		314
		315	+def ShowImportBitmapDirDialog():
		316	+ current_dir = os.path.abspath(".")
		317	+
		318	+ if (sys.platform == 'win32') or (sys.platform == 'linux2'):
		319	+ session = ses.Session()
		320	+
		321	+ if (session.GetLastDicomFolder()):
		322	+ folder = session.GetLastDicomFolder()
		323	+ else:
		324	+ folder = ''
		325	+ else:
		326	+ folder = ''
		327	+
		328	+ dlg = wx.DirDialog(None, _("Choose a folder with TIFF, BMP, JPG or PNG:"), folder,
		329	+ style=wx.DD_DEFAULT_STYLE
		330	+ \| wx.DD_DIR_MUST_EXIST
		331	+ \| wx.DD_CHANGE_DIR)
		332	+
		333	+ path = None
		334	+ try:
		335	+ if dlg.ShowModal() == wx.ID_OK:
		336	+ # GetPath returns in unicode, if a path has non-ascii characters a
		337	+ # UnicodeEncodeError is raised. To avoid this, path is encoded in utf-8
		338	+ if sys.platform == "win32":
		339	+ path = dlg.GetPath()
		340	+ else:
		341	+ path = dlg.GetPath().encode('utf-8')
		342	+
		343	+ except(wx._core.PyAssertionError): #TODO: error win64
		344	+ if (dlg.GetPath()):
		345	+ path = dlg.GetPath()
		346	+
		347	+ if (sys.platform != 'darwin'):
		348	+ if (path):
		349	+ session.SetLastDicomFolder(path)
		350	+
		351	+ # Only destroy a dialog after you're done with it.
		352	+ dlg.Destroy()
		353	+ os.chdir(current_dir)
		354	+ return path
		355	+
		356	+
309	def ShowSaveAsProjectDialog(default_filename=None):	357	def ShowSaveAsProjectDialog(default_filename=None):
310	current_dir = os.path.abspath(".")	358	current_dir = os.path.abspath(".")
311	dlg = wx.FileDialog(None,	359	dlg = wx.FileDialog(None,
	@@ -1630,3 +1678,114 @@ class ReorientImageDialog(wx.Dialog):		@@ -1630,3 +1678,114 @@ class ReorientImageDialog(wx.Dialog):
1630	Publisher.sendMessage('Disable style', const.SLICE_STATE_REORIENT)	1678	Publisher.sendMessage('Disable style', const.SLICE_STATE_REORIENT)
1631	Publisher.sendMessage('Enable style', const.STATE_DEFAULT)	1679	Publisher.sendMessage('Enable style', const.STATE_DEFAULT)
1632	self.Destroy()	1680	self.Destroy()
		1681	+
		1682	+
		1683	+
		1684	+class ImportBitmapParameters(wx.Dialog):
		1685	+
		1686	+ def __init__(self):
		1687	+ pre = wx.PreDialog()
		1688	+ pre.Create(wx.GetApp().GetTopWindow(), -1, _(u"Parameters"),size=wx.Size(380,230),\
		1689	+ style=wx.DEFAULT_DIALOG_STYLE\|wx.FRAME_FLOAT_ON_PARENT\|wx.STAY_ON_TOP)
		1690	+
		1691	+ self.interval = 0
		1692	+
		1693	+ self.PostCreate(pre)
		1694	+
		1695	+ self._init_gui()
		1696	+
		1697	+ self.bind_evts()
		1698	+ self.CenterOnScreen()
		1699	+
		1700	+
		1701	+ def _init_gui(self):
		1702	+
		1703	+
		1704	+ p = wx.Panel(self, -1, style = wx.TAB_TRAVERSAL
		1705	+ \| wx.CLIP_CHILDREN
		1706	+ \| wx.FULL_REPAINT_ON_RESIZE)
		1707	+
		1708	+ gbs_principal = self.gbs = wx.GridBagSizer(3,1)
		1709	+
		1710	+ gbs = self.gbs = wx.GridBagSizer(4, 2)
		1711	+
		1712	+ stx_name = wx.StaticText(p, -1, _(u"Project name:"))
		1713	+ tx_name = self.tx_name = wx.TextCtrl(p, -1, "InVesalius Bitmap", size=wx.Size(220,-1))
		1714	+
		1715	+ stx_orientation = wx.StaticText(p, -1, _(u"Slices orientation:"))
		1716	+ cb_orientation_options = [_(u'Axial'), _(u'Coronal'), _(u'Sagital')]
		1717	+ cb_orientation = self.cb_orientation = wx.ComboBox(p, value="Axial", choices=cb_orientation_options,\
		1718	+ size=wx.Size(160,-1), style=wx.CB_DROPDOWN\|wx.CB_READONLY)
		1719	+
		1720	+ stx_spacing = wx.StaticText(p, -1, _(u"Spacing (mm):"))
		1721	+
		1722	+ gbs.Add(stx_name, (0,0))
		1723	+ gbs.Add(tx_name, (0,1))
		1724	+
		1725	+ gbs.Add(stx_orientation, (1,0))
		1726	+ gbs.Add(cb_orientation, (1,1))
		1727	+
		1728	+ gbs.Add(stx_spacing, (2,0))
		1729	+
		1730	+ #--- spacing --------------
		1731	+ gbs_spacing = wx.GridBagSizer(2, 6)
		1732	+
		1733	+ stx_spacing_x = stx_spacing_x = wx.StaticText(p, -1, _(u"X:"))
		1734	+ fsp_spacing_x = self.fsp_spacing_x = FS.FloatSpin(p, -1, min_val=0,\
		1735	+ increment=0.25, value=1.0, digits=6)
		1736	+
		1737	+ stx_spacing_y = stx_spacing_y = wx.StaticText(p, -1, _(u"Y:"))
		1738	+ fsp_spacing_y = self.fsp_spacing_y = FS.FloatSpin(p, -1, min_val=0,\
		1739	+ increment=0.25, value=1.0, digits=6)
		1740	+
		1741	+ stx_spacing_z = stx_spacing_z = wx.StaticText(p, -1, _(u"Z:"))
		1742	+ fsp_spacing_z = self.fsp_spacing_z = FS.FloatSpin(p, -1, min_val=0,\
		1743	+ increment=0.25, value=1.0, digits=6)
		1744	+
		1745	+ gbs_spacing.Add(stx_spacing_x, (0,0))
		1746	+ gbs_spacing.Add(fsp_spacing_x, (0,1))
		1747	+
		1748	+ gbs_spacing.Add(stx_spacing_y, (0,2))
		1749	+ gbs_spacing.Add(fsp_spacing_y, (0,3))
		1750	+
		1751	+ gbs_spacing.Add(stx_spacing_z, (0,4))
		1752	+ gbs_spacing.Add(fsp_spacing_z, (0,5))
		1753	+
		1754	+ #----- buttons ------------------------
		1755	+ gbs_button = wx.GridBagSizer(1, 4)
		1756	+
		1757	+ btn_ok = self.btn_ok= wx.Button(p, wx.ID_OK)
		1758	+ btn_ok.SetDefault()
		1759	+
		1760	+ btn_cancel = wx.Button(p, wx.ID_CANCEL)
		1761	+
		1762	+ gbs_button.Add(btn_cancel, (1,2))
		1763	+ gbs_button.Add(btn_ok, (1,3))
		1764	+
		1765	+
		1766	+ gbs_principal.Add(gbs, (0,0))
		1767	+ gbs_principal.Add(gbs_spacing, (1,0))
		1768	+ gbs_principal.Add(gbs_button, (2,0), flag = wx.ALIGN_RIGHT)
		1769	+
		1770	+ box = wx.BoxSizer()
		1771	+ box.Add(gbs_principal, 1, wx.ALL\|wx.EXPAND, 10)
		1772	+
		1773	+ p.SetSizer(box)
		1774	+
		1775	+
		1776	+ def bind_evts(self):
		1777	+ self.btn_ok.Bind(wx.EVT_BUTTON, self.OnOk)
		1778	+
		1779	+ def SetInterval(self, v):
		1780	+ self.interval = v
		1781	+
		1782	+ def OnOk(self, evt):
		1783	+ self.Close()
		1784	+ self.Destroy()
		1785	+
		1786	+ values = [self.tx_name.GetValue(), self.cb_orientation.GetValue().upper(),\
		1787	+ self.fsp_spacing_x.GetValue(), self.fsp_spacing_y.GetValue(),\
		1788	+ self.fsp_spacing_z.GetValue(), self.interval]
		1789	+ Publisher.sendMessage('Open bitmap files', values)
		1790	+
		1791	+
@@ -0,0 +1,484 @@		@@ -0,0 +1,484 @@
	1	+#--------------------------------------------------------------------------
	2	+# Software: InVesalius - Software de Reconstrucao 3D de Imagens Medicas
	3	+# Copyright: (C) 2001 Centro de Pesquisas Renato Archer
	4	+# Homepage: http://www.softwarepublico.gov.br
	5	+# Contact: invesalius@cti.gov.br
	6	+# License: GNU - GPL 2 (LICENSE.txt/LICENCA.txt)
	7	+#--------------------------------------------------------------------------
	8	+# Este programa e software livre; voce pode redistribui-lo e/ou
	9	+# modifica-lo sob os termos da Licenca Publica Geral GNU, conforme
	10	+# publicada pela Free Software Foundation; de acordo com a versao 2
	11	+# da Licenca.
	12	+#
	13	+# Este programa eh distribuido na expectativa de ser util, mas SEM
	14	+# QUALQUER GARANTIA; sem mesmo a garantia implicita de
	15	+# COMERCIALIZACAO ou de ADEQUACAO A QUALQUER PROPOSITO EM
	16	+# PARTICULAR. Consulte a Licenca Publica Geral GNU para obter mais
	17	+# detalhes.
	18	+#--------------------------------------------------------------------------
	19	+import wx
	20	+import wx.gizmos as gizmos
	21	+from wx.lib.pubsub import pub as Publisher
	22	+import wx.lib.splitter as spl
	23	+
	24	+import constants as const
	25	+import gui.dialogs as dlg
	26	+import bitmap_preview_panel as bpp
	27	+import reader.dicom_grouper as dcm
	28	+from dialogs import ImportBitmapParameters
	29	+
	30	+myEVT_SELECT_SERIE = wx.NewEventType()
	31	+EVT_SELECT_SERIE = wx.PyEventBinder(myEVT_SELECT_SERIE, 1)
	32	+
	33	+myEVT_SELECT_SLICE = wx.NewEventType()
	34	+EVT_SELECT_SLICE = wx.PyEventBinder(myEVT_SELECT_SLICE, 1)
	35	+
	36	+myEVT_SELECT_PATIENT = wx.NewEventType()
	37	+EVT_SELECT_PATIENT = wx.PyEventBinder(myEVT_SELECT_PATIENT, 1)
	38	+
	39	+myEVT_SELECT_SERIE_TEXT = wx.NewEventType()
	40	+EVT_SELECT_SERIE_TEXT = wx.PyEventBinder(myEVT_SELECT_SERIE_TEXT, 1)
	41	+
	42	+class SelectEvent(wx.PyCommandEvent):
	43	+ def __init__(self , evtType, id):
	44	+ super(SelectEvent, self).__init__(evtType, id)
	45	+
	46	+ def GetSelectID(self):
	47	+ return self.SelectedID
	48	+
	49	+ def SetSelectedID(self, id):
	50	+ self.SelectedID = id
	51	+
	52	+ def GetItemData(self):
	53	+ return self.data
	54	+
	55	+ def SetItemData(self, data):
	56	+ self.data = data
	57	+
	58	+
	59	+class Panel(wx.Panel):
	60	+ def __init__(self, parent):
	61	+ wx.Panel.__init__(self, parent, pos=wx.Point(5, 5))#,
	62	+ #size=wx.Size(280, 656))
	63	+
	64	+ sizer = wx.BoxSizer(wx.VERTICAL)
	65	+ sizer.Add(InnerPanel(self), 1, wx.EXPAND\|wx.GROW\|wx.ALL, 5)
	66	+
	67	+ self.SetSizer(sizer)
	68	+ sizer.Fit(self)
	69	+
	70	+ self.Layout()
	71	+ self.Update()
	72	+ self.SetAutoLayout(1)
	73	+
	74	+
	75	+# Inner fold panel
	76	+class InnerPanel(wx.Panel):
	77	+ def __init__(self, parent):
	78	+ wx.Panel.__init__(self, parent, pos=wx.Point(5, 5))#,
	79	+ #size=wx.Size(680, 656))
	80	+
	81	+ self.patients = []
	82	+ self.first_image_selection = None
	83	+ self.last_image_selection = None
	84	+ self._init_ui()
	85	+ self._bind_events()
	86	+ self._bind_pubsubevt()
	87	+
	88	+ def _init_ui(self):
	89	+ splitter = spl.MultiSplitterWindow(self, style=wx.SP_LIVE_UPDATE)
	90	+ splitter.SetOrientation(wx.VERTICAL)
	91	+ self.splitter = splitter
	92	+
	93	+ panel = wx.Panel(self)
	94	+ self.btn_cancel = wx.Button(panel, wx.ID_CANCEL)
	95	+ self.btn_ok = wx.Button(panel, wx.ID_OK, _("Import"))
	96	+
	97	+ btnsizer = wx.StdDialogButtonSizer()
	98	+ btnsizer.AddButton(self.btn_ok)
	99	+ btnsizer.AddButton(self.btn_cancel)
	100	+ btnsizer.Realize()
	101	+
	102	+ self.combo_interval = wx.ComboBox(panel, -1, "", choices=const.IMPORT_INTERVAL,
	103	+ style=wx.CB_DROPDOWN\|wx.CB_READONLY)
	104	+ self.combo_interval.SetSelection(0)
	105	+
	106	+ inner_sizer = wx.BoxSizer(wx.HORIZONTAL)
	107	+ inner_sizer.AddSizer(btnsizer, 0, wx.LEFT\|wx.TOP, 5)
	108	+ inner_sizer.Add(self.combo_interval, 0, wx.LEFT\|wx.RIGHT\|wx.TOP, 5)
	109	+ panel.SetSizer(inner_sizer)
	110	+ inner_sizer.Fit(panel)
	111	+
	112	+ sizer = wx.BoxSizer(wx.VERTICAL)
	113	+ sizer.Add(splitter, 20, wx.EXPAND)
	114	+ sizer.Add(panel, 0, wx.EXPAND\|wx.LEFT, 90)
	115	+
	116	+ self.text_panel = TextPanel(splitter)
	117	+ splitter.AppendWindow(self.text_panel, 250)
	118	+
	119	+ self.image_panel = ImagePanel(splitter)
	120	+ splitter.AppendWindow(self.image_panel, 250)
	121	+
	122	+ self.SetSizer(sizer)
	123	+ sizer.Fit(self)
	124	+
	125	+ self.Layout()
	126	+ self.Update()
	127	+ self.SetAutoLayout(1)
	128	+
	129	+ def _bind_pubsubevt(self):
	130	+ Publisher.subscribe(self.ShowBitmapPreview, "Load import bitmap panel")
	131	+ Publisher.subscribe(self.GetSelectedImages ,"Selected Import Images")
	132	+
	133	+ def ShowBitmapPreview(self, pubsub_evt):
	134	+ data = pubsub_evt.data
	135	+ #self.patients.extend(dicom_groups)
	136	+ self.text_panel.Populate(data)
	137	+
	138	+ def GetSelectedImages(self, pubsub_evt):
	139	+ self.first_image_selection = pubsub_evt.data[0]
	140	+ self.last_image_selection = pubsub_evt.data[1]
	141	+
	142	+ def _bind_events(self):
	143	+ self.Bind(EVT_SELECT_SERIE, self.OnSelectSerie)
	144	+ self.Bind(EVT_SELECT_SLICE, self.OnSelectSlice)
	145	+ self.Bind(EVT_SELECT_PATIENT, self.OnSelectPatient)
	146	+ self.btn_ok.Bind(wx.EVT_BUTTON, self.OnClickOk)
	147	+ self.btn_cancel.Bind(wx.EVT_BUTTON, self.OnClickCancel)
	148	+ self.text_panel.Bind(EVT_SELECT_SERIE_TEXT, self.OnDblClickTextPanel)
	149	+
	150	+ def OnSelectSerie(self, evt):
	151	+ #patient_id, serie_number = evt.GetSelectID()
	152	+ #self.text_panel.SelectSerie(evt.GetSelectID())
	153	+ #for patient in self.patients:
	154	+ # if patient_id == patient.GetDicomSample().patient.id:
	155	+ # for group in patient.GetGroups():
	156	+ # if serie_number == group.GetDicomSample().acquisition.serie_number:
	157	+ # self.image_panel.SetSerie(group)
	158	+
	159	+ pass
	160	+
	161	+
	162	+
	163	+ def OnSelectSlice(self, evt):
	164	+ pass
	165	+
	166	+ def OnSelectPatient(self, evt):
	167	+ pass
	168	+
	169	+ def OnDblClickTextPanel(self, evt):
	170	+ group = evt.GetItemData()
	171	+ self.LoadDicom(group)
	172	+
	173	+ def OnClickOk(self, evt):
	174	+ parm = dlg.ImportBitmapParameters()
	175	+ parm.SetInterval(self.combo_interval.GetSelection())
	176	+ parm.ShowModal()
	177	+
	178	+ group = self.text_panel.GetSelection()
	179	+ if group:
	180	+ self.LoadDicom(group)
	181	+
	182	+ def OnClickCancel(self, evt):
	183	+ Publisher.sendMessage("Cancel DICOM load")
	184	+
	185	+ def LoadDicom(self, group):
	186	+ #interval = self.combo_interval.GetSelection()
	187	+ #if not isinstance(group, dcm.DicomGroup):
	188	+ # group = max(group.GetGroups(), key=lambda g: g.nslices)
	189	+
	190	+ #slice_amont = group.nslices
	191	+ #if (self.first_image_selection != None) and (self.first_image_selection != self.last_image_selection):
	192	+ # slice_amont = (self.last_image_selection) - self.first_image_selection
	193	+ # slice_amont += 1
	194	+ # if slice_amont == 0:
	195	+ # slice_amont = group.nslices
	196	+
	197	+ #nslices_result = slice_amont / (interval + 1)
	198	+ #if (nslices_result > 1):
	199	+ # Publisher.sendMessage('Open DICOM group', (group, interval,
	200	+ # [self.first_image_selection, self.last_image_selection]))
	201	+ #else:
	202	+ # dlg.MissingFilesForReconstruction()
	203	+ pass
	204	+
	205	+
	206	+class TextPanel(wx.Panel):
	207	+ def __init__(self, parent):
	208	+ wx.Panel.__init__(self, parent, -1)
	209	+
	210	+ self._selected_by_user = True
	211	+ self.idserie_treeitem = {}
	212	+ self.treeitem_idpatient = {}
	213	+
	214	+ self.__init_gui()
	215	+ self.__bind_events_wx()
	216	+ self.__bind_pubsub_evt()
	217	+
	218	+ def __bind_pubsub_evt(self):
	219	+ Publisher.subscribe(self.SelectSeries, 'Select series in import panel')
	220	+
	221	+ def __bind_events_wx(self):
	222	+ self.Bind(wx.EVT_SIZE, self.OnSize)
	223	+
	224	+ def __init_gui(self):
	225	+ tree = gizmos.TreeListCtrl(self, -1, style =
	226	+ wx.TR_DEFAULT_STYLE
	227	+ \| wx.TR_HIDE_ROOT
	228	+ \| wx.TR_ROW_LINES
	229	+ \| wx.TR_COLUMN_LINES
	230	+ \| wx.TR_FULL_ROW_HIGHLIGHT
	231	+ \| wx.TR_SINGLE
	232	+ \| wx.TR_HIDE_ROOT
	233	+ )
	234	+
	235	+
	236	+ tree.AddColumn(_("Path"))
	237	+ tree.AddColumn(_("Type"))
	238	+ tree.AddColumn(_("Width x Height"))
	239	+
	240	+
	241	+ tree.SetMainColumn(0)
	242	+ tree.SetColumnWidth(0, 880)
	243	+ tree.SetColumnWidth(1, 60)
	244	+ tree.SetColumnWidth(2, 130)
	245	+
	246	+ self.root = tree.AddRoot(_("InVesalius Database"))
	247	+ self.tree = tree
	248	+
	249	+ def SelectSeries(self, pubsub_evt):
	250	+ group_index = pubsub_evt.data
	251	+
	252	+ def Populate(self, data):
	253	+ tree = self.tree
	254	+ for value in data:
	255	+ parent = tree.AppendItem(self.root, value[0])
	256	+ self.tree.SetItemText(parent, value[2], 1)
	257	+ self.tree.SetItemText(parent, value[5], 2)
	258	+
	259	+ tree.Expand(self.root)
	260	+ #tree.SelectItem(parent_select)
	261	+ tree.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnActivate)
	262	+ tree.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged)
	263	+
	264	+ Publisher.sendMessage('Load bitmap into import panel', data)
	265	+
	266	+
	267	+ def OnSelChanged(self, evt):
	268	+ item = self.tree.GetSelection()
	269	+ if self._selected_by_user:
	270	+ group = self.tree.GetItemPyData(item)
	271	+ if isinstance(group, dcm.DicomGroup):
	272	+ Publisher.sendMessage('Load group into import panel',
	273	+ group)
	274	+
	275	+ elif isinstance(group, dcm.PatientGroup):
	276	+ id = group.GetDicomSample().patient.id
	277	+ my_evt = SelectEvent(myEVT_SELECT_PATIENT, self.GetId())
	278	+ my_evt.SetSelectedID(id)
	279	+ self.GetEventHandler().ProcessEvent(my_evt)
	280	+
	281	+ Publisher.sendMessage('Load bitmap into import panel',
	282	+
	283	+ group)
	284	+ else:
	285	+ parent_id = self.tree.GetItemParent(item)
	286	+ self.tree.Expand(parent_id)
	287	+ evt.Skip()
	288	+
	289	+ def OnActivate(self, evt):
	290	+ item = evt.GetItem()
	291	+ group = self.tree.GetItemPyData(item)
	292	+ my_evt = SelectEvent(myEVT_SELECT_SERIE_TEXT, self.GetId())
	293	+ my_evt.SetItemData(group)
	294	+ self.GetEventHandler().ProcessEvent(my_evt)
	295	+
	296	+ def OnSize(self, evt):
	297	+ self.tree.SetSize(self.GetSize())
	298	+
	299	+ def SelectSerie(self, serie):
	300	+ self._selected_by_user = False
	301	+ item = self.idserie_treeitem[serie]
	302	+ self.tree.SelectItem(item)
	303	+ self._selected_by_user = True
	304	+
	305	+ def GetSelection(self):
	306	+ """Get selected item"""
	307	+ item = self.tree.GetSelection()
	308	+ group = self.tree.GetItemPyData(item)
	309	+ return group
	310	+
	311	+
	312	+class ImagePanel(wx.Panel):
	313	+ def __init__(self, parent):
	314	+ wx.Panel.__init__(self, parent, -1)
	315	+ self._init_ui()
	316	+ self._bind_events()
	317	+
	318	+ def _init_ui(self):
	319	+ splitter = spl.MultiSplitterWindow(self, style=wx.SP_LIVE_UPDATE)
	320	+ splitter.SetOrientation(wx.HORIZONTAL)
	321	+ self.splitter = splitter
	322	+
	323	+ splitter.ContainingSizer = wx.BoxSizer(wx.HORIZONTAL)
	324	+
	325	+ sizer = wx.BoxSizer(wx.HORIZONTAL)
	326	+ sizer.Add(splitter, 1, wx.EXPAND)
	327	+ self.SetSizer(sizer)
	328	+
	329	+ self.text_panel = SeriesPanel(splitter)
	330	+ splitter.AppendWindow(self.text_panel, 600)
	331	+
	332	+ self.image_panel = SlicePanel(splitter)
	333	+ splitter.AppendWindow(self.image_panel, 250)
	334	+
	335	+ self.SetSizer(sizer)
	336	+ sizer.Fit(self)
	337	+
	338	+ self.Layout()
	339	+ self.Update()
	340	+ self.SetAutoLayout(1)
	341	+
	342	+ def _bind_events(self):
	343	+ self.text_panel.Bind(EVT_SELECT_SERIE, self.OnSelectSerie)
	344	+ self.text_panel.Bind(EVT_SELECT_SLICE, self.OnSelectSlice)
	345	+
	346	+ def OnSelectSerie(self, evt):
	347	+ evt.Skip()
	348	+
	349	+ def OnSelectSlice(self, evt):
	350	+ self.image_panel.bitmap_preview.ShowSlice(evt.GetSelectID())
	351	+ evt.Skip()
	352	+
	353	+ def SetSerie(self, serie):
	354	+ self.image_panel.bitmap_preview.SetDicomGroup(serie)
	355	+
	356	+
	357	+class SeriesPanel(wx.Panel):
	358	+ def __init__(self, parent):
	359	+ wx.Panel.__init__(self, parent, -1)
	360	+ #self.SetBackgroundColour((0,0,0))
	361	+
	362	+ self.thumbnail_preview = bpp.BitmapPreviewSeries(self)
	363	+ #self.bitmap_preview = bpp.BitmapPreviewSlice(self)
	364	+ #self.bitmap_preview.Show(0)
	365	+
	366	+
	367	+ self.sizer = wx.BoxSizer(wx.HORIZONTAL)
	368	+ self.sizer.Add(self.thumbnail_preview, 1, wx.EXPAND \| wx.ALL, 5)
	369	+ #self.sizer.Add(self.bitmap_preview, 1, wx.EXPAND \| wx.ALL, 5)
	370	+ self.sizer.Fit(self)
	371	+
	372	+ self.SetSizer(self.sizer)
	373	+
	374	+ self.Layout()
	375	+ self.Update()
	376	+ self.SetAutoLayout(1)
	377	+
	378	+ self.__bind_evt()
	379	+ self._bind_gui_evt()
	380	+
	381	+ def __bind_evt(self):
	382	+ #Publisher.subscribe(self.ShowDicomSeries, 'Load bitmap preview')
	383	+ #Publisher.subscribe(self.SetDicomSeries, 'Load group into import panel')
	384	+ Publisher.subscribe(self.SetBitmapFiles, 'Load bitmap into import panel')
	385	+
	386	+ def _bind_gui_evt(self):
	387	+ self.thumbnail_preview.Bind(bpp.EVT_CLICK_SERIE, self.OnSelectSerie)
	388	+ #self.bitmap_preview.Bind(bpp.EVT_CLICK_SLICE, self.OnSelectSlice)
	389	+
	390	+ #def SetDicomSeries(self, pubsub_evt):
	391	+ # group = pubsub_evt.data
	392	+ # self.bitmap_preview.SetDicomGroup(group)
	393	+ # self.bitmap_preview.Show(1)
	394	+ # self.thumbnail_preview.Show(0)
	395	+ # self.sizer.Layout()
	396	+ # self.Update()
	397	+
	398	+ def GetSelectedImagesRange(self):
	399	+ return [self.bitmap_preview.first_selected, self.dicom_preview_last_selection]
	400	+
	401	+ def SetBitmapFiles(self, pubsub_evt):
	402	+
	403	+
	404	+ bitmap = pubsub_evt.data
	405	+ #self.bitmap_preview.Show(0)
	406	+ self.thumbnail_preview.Show(1)
	407	+
	408	+ self.thumbnail_preview.SetBitmapFiles(bitmap)
	409	+ #self.bitmap_preview.SetPatientGroups(patient)
	410	+
	411	+ self.Update()
	412	+
	413	+ def OnSelectSerie(self, evt):
	414	+ data = evt.GetItemData()
	415	+
	416	+ my_evt = SelectEvent(myEVT_SELECT_SERIE, self.GetId())
	417	+ my_evt.SetSelectedID(evt.GetSelectID())
	418	+ my_evt.SetItemData(evt.GetItemData())
	419	+ self.GetEventHandler().ProcessEvent(my_evt)
	420	+
	421	+ #self.bitmap_preview.SetDicomGroup(data)
	422	+ #self.bitmap_preview.Show(1)
	423	+ #self.thumbnail_preview.Show(0)
	424	+ self.sizer.Layout()
	425	+ self.Show()
	426	+ self.Update()
	427	+
	428	+ def OnSelectSlice(self, evt):
	429	+ my_evt = SelectEvent(myEVT_SELECT_SLICE, self.GetId())
	430	+ my_evt.SetSelectedID(evt.GetSelectID())
	431	+ my_evt.SetItemData(evt.GetItemData())
	432	+ self.GetEventHandler().ProcessEvent(my_evt)
	433	+
	434	+
	435	+ #def ShowDicomSeries(self, pubsub_evt):
	436	+ # patient = pubsub_evt.data
	437	+ # if isinstance(patient, dcm.PatientGroup):
	438	+ # self.thumbnail_preview.SetPatientGroups(patient)
	439	+ # self.bitmap_preview.SetPatientGroups(patient)
	440	+
	441	+
	442	+class SlicePanel(wx.Panel):
	443	+ def __init__(self, parent):
	444	+ wx.Panel.__init__(self, parent, -1)
	445	+ self.__init_gui()
	446	+ self.__bind_evt()
	447	+
	448	+ def __bind_evt(self):
	449	+ #Publisher.subscribe(self.ShowDicomSeries, 'Load bitmap preview')
	450	+ #Publisher.subscribe(self.SetDicomSeries, 'Load group into import panel')
	451	+ Publisher.subscribe(self.SetBitmapFiles, 'Load bitmap into import panel')
	452	+
	453	+ def __init_gui(self):
	454	+ self.SetBackgroundColour((255,255,255))
	455	+ self.bitmap_preview = bpp.SingleImagePreview(self)
	456	+
	457	+ sizer = wx.BoxSizer(wx.VERTICAL)
	458	+ sizer.Add(self.bitmap_preview, 1, wx.GROW\|wx.EXPAND)
	459	+ sizer.Fit(self)
	460	+ self.SetSizer(sizer)
	461	+ self.Layout()
	462	+ self.Update()
	463	+ self.SetAutoLayout(1)
	464	+ self.sizer = sizer
	465	+
	466	+ def SetBitmapFiles(self, pubsub_evt):
	467	+ data = pubsub_evt.data
	468	+ self.bitmap_preview.SetBitmapFiles(data)
	469	+ self.sizer.Layout()
	470	+ self.Update()
	471	+
	472	+ #def SetDicomSeries(self, evt):
	473	+ # group = evt.data
	474	+ # self.bitmap_preview.SetDicomGroup(group)
	475	+ # self.sizer.Layout()
	476	+ # self.Update()
	477	+
	478	+ #def ShowDicomSeries(self, pubsub_evt):
	479	+ # patient = pubsub_evt.data
	480	+ # group = patient.GetGroups()[0]
	481	+ # self.bitmap_preview.SetDicomGroup(group)
	482	+ # self.sizer.Layout()
	483	+ # self.Update()
	484	+
@@ -0,0 +1,389 @@		@@ -0,0 +1,389 @@
	1	+#--------------------------------------------------------------------------
	2	+# Software: InVesalius - Software de Reconstrucao 3D de Imagens Medicas
	3	+# Copyright: (C) 2001 Centro de Pesquisas Renato Archer
	4	+# Homepage: http://www.softwarepublico.gov.br
	5	+# Contact: invesalius@cti.gov.br
	6	+# License: GNU - GPL 2 (LICENSE.txt/LICENCA.txt)
	7	+#--------------------------------------------------------------------------
	8	+# Este programa e software livre; voce pode redistribui-lo e/ou
	9	+# modifica-lo sob os termos da Licenca Publica Geral GNU, conforme
	10	+# publicada pela Free Software Foundation; de acordo com a versao 2
	11	+# da Licenca.
	12	+#
	13	+# Este programa eh distribuido na expectativa de ser util, mas SEM
	14	+# QUALQUER GARANTIA; sem mesmo a garantia implicita de
	15	+# COMERCIALIZACAO ou de ADEQUACAO A QUALQUER PROPOSITO EM
	16	+# PARTICULAR. Consulte a Licenca Publica Geral GNU para obter mais
	17	+# detalhes.
	18	+#--------------------------------------------------------------------------
	19	+import os
	20	+import Queue
	21	+import threading
	22	+import tempfile
	23	+import sys
	24	+import vtk
	25	+import re
	26	+import constants as const
	27	+import wx
	28	+
	29	+from wx.lib.pubsub import pub as Publisher
	30	+from multiprocessing import cpu_count
	31	+
	32	+from vtk.util import numpy_support
	33	+from scipy import misc
	34	+import numpy
	35	+import imghdr
	36	+
	37	+from data import converters
	38	+
	39	+#flag to control vtk error in read files
	40	+no_error = True
	41	+vtk_error = False
	42	+
	43	+class Singleton:
	44	+
	45	+ def __init__(self,klass):
	46	+ self.klass = klass
	47	+ self.instance = None
	48	+
	49	+ def __call__(self,args,*kwds):
	50	+ if self.instance == None:
	51	+ self.instance = self.klass(args,*kwds)
	52	+ return self.instance
	53	+
	54	+@Singleton
	55	+class BitmapData:
	56	+
	57	+ def __init__(self):
	58	+ self.data = None
	59	+
	60	+ def GetData(self):
	61	+ return self.data
	62	+
	63	+ def SetData(self, data):
	64	+ self.data = data
	65	+
	66	+ def GetOnlyBitmapPath(self):
	67	+ paths = [item[0] for item in self.data]
	68	+ return paths
	69	+
	70	+ def GetFirstBitmapSize(self):
	71	+ return (self.data[0][3], self.data[0][4])
	72	+
	73	+ def IsAllBitmapSameSize(self):
	74	+ sizes = [item[5] for item in self.data]
	75	+
	76	+ k = {}
	77	+ for v in sizes:
	78	+ k[v] = ''
	79	+
	80	+ if len(k.keys()) > 1:
	81	+ return False
	82	+ else:
	83	+ return True
	84	+
	85	+ def GetFirstPixelSize(self):
	86	+
	87	+ path = self.data[0][0]
	88	+ size = ReadBitmap(path).dtype.itemsize * 8
	89	+
	90	+ return size
	91	+
	92	+
	93	+
	94	+class BitmapFiles:
	95	+
	96	+ def __init__(self):
	97	+ self.bitmapfiles = []
	98	+
	99	+ def Add(self, bmp):
	100	+ self.bitmapfiles.append(bmp)
	101	+
	102	+ def Sort(self, x):
	103	+
	104	+ c_re = re.compile('\d+')
	105	+
	106	+ if len(c_re.findall(x[0])) > 0:
	107	+ return c_re.findall(x[0])[-1]
	108	+ else:
	109	+ return '0'
	110	+
	111	+ def GetValues(self):
	112	+ bmpfile = self.bitmapfiles
	113	+ bmpfile.sort(key = self.Sort)
	114	+
	115	+ bmp_data = BitmapData()
	116	+ bmp_data.data = bmpfile
	117	+
	118	+ return bmpfile
	119	+
	120	+class LoadBitmap:
	121	+
	122	+ def __init__(self, bmp_file, filepath):
	123	+ self.bmp_file = bmp_file
	124	+ if sys.platform == 'win32':
	125	+ self.filepath = filepath.encode(utils.get_system_encoding())
	126	+ else:
	127	+ self.filepath = filepath
	128	+
	129	+ self.run()
	130	+
	131	+ def run(self):
	132	+ global vtk_error
	133	+
	134	+ #----- verify extension ------------------
	135	+ #ex = self.filepath.split('.')[-1]
	136	+ extension = VerifyDataType(self.filepath)
	137	+
	138	+ file_name = self.filepath.split(os.path.sep)[-1]
	139	+
	140	+ #if extension == 'bmp':
	141	+ # reader = vtk.vtkBMPReader()
	142	+ n_array = ReadBitmap(self.filepath)
	143	+
	144	+ if not(isinstance(n_array, numpy.ndarray)):
	145	+ return False
	146	+
	147	+ image = converters.to_vtk(n_array, spacing=(1,1,1),\
	148	+ slice_number=1, orientation="AXIAL")
	149	+
	150	+
	151	+ #reader.SetFileName(self.filepath)
	152	+ #reader.Update()
	153	+
	154	+ dim = image.GetDimensions()
	155	+ x = dim[0]
	156	+ y = dim[1]
	157	+
	158	+ img = vtk.vtkImageResample()
	159	+ img.SetInputData(image)
	160	+ img.SetAxisMagnificationFactor ( 0, 0.25 )
	161	+ img.SetAxisMagnificationFactor ( 1, 0.25 )
	162	+ img.SetAxisMagnificationFactor ( 2, 1 )
	163	+ img.Update()
	164	+
	165	+ tp = img.GetOutput().GetScalarTypeAsString()
	166	+
	167	+ image_copy = vtk.vtkImageData()
	168	+ image_copy.DeepCopy(img.GetOutput())
	169	+
	170	+ thumbnail_path = tempfile.mktemp()
	171	+
	172	+ write_png = vtk.vtkPNGWriter()
	173	+ write_png.SetInputConnection(img.GetOutputPort())
	174	+ write_png.AddObserver("WarningEvent", VtkErrorPNGWriter)
	175	+ write_png.SetFileName(thumbnail_path)
	176	+ write_png.Write()
	177	+
	178	+ if vtk_error:
	179	+ img = vtk.vtkImageCast()
	180	+ img.SetInputData(image_copy)
	181	+ img.SetOutputScalarTypeToUnsignedShort()
	182	+ #img.SetClampOverflow(1)
	183	+ img.Update()
	184	+
	185	+ write_png = vtk.vtkPNGWriter()
	186	+ write_png.SetInputConnection(img.GetOutputPort())
	187	+ write_png.SetFileName(thumbnail_path)
	188	+ write_png.Write()
	189	+
	190	+ vtk_error = False
	191	+
	192	+ id = wx.NewId()
	193	+
	194	+ bmp_item = [self.filepath, thumbnail_path, extension, x, y,\
	195	+ str(x) + ' x ' + str(y), file_name, id]
	196	+ self.bmp_file.Add(bmp_item)
	197	+
	198	+
	199	+def yGetBitmaps(directory, recursive=True, gui=True):
	200	+ """
	201	+ Return all full paths to DICOM files inside given directory.
	202	+ """
	203	+ nfiles = 0
	204	+ # Find total number of files
	205	+ if recursive:
	206	+ for dirpath, dirnames, filenames in os.walk(directory):
	207	+ nfiles += len(filenames)
	208	+ else:
	209	+ dirpath, dirnames, filenames = os.walk(directory)
	210	+ nfiles = len(filenames)
	211	+
	212	+
	213	+ counter = 0
	214	+ bmp_file = BitmapFiles()
	215	+
	216	+ # Retrieve only TIFF, BMP, JPEG and PNG files
	217	+ if recursive:
	218	+ for dirpath, dirnames, filenames in os.walk(directory):
	219	+ for name in filenames:
	220	+ filepath = os.path.join(dirpath, name)
	221	+ counter += 1
	222	+ if gui:
	223	+ yield (counter,nfiles)
	224	+ #LoadDicom(grouper, filepath)
	225	+ LoadBitmap(bmp_file, filepath)
	226	+ else:
	227	+ dirpath, dirnames, filenames = os.walk(directory)
	228	+ for name in filenames:
	229	+ filepath = str(os.path.join(dirpath, name))
	230	+ counter += 1
	231	+ if gui:
	232	+ yield (counter,nfiles)
	233	+ #q.put(filepath)
	234	+
	235	+ #for t in threads:
	236	+ # q.put(0)
	237	+
	238	+ #for t in threads:
	239	+ # t.join()
	240	+
	241	+ #TODO: Is this commented update necessary?
	242	+ #grouper.Update()
	243	+ yield bmp_file.GetValues()
	244	+
	245	+
	246	+class ProgressBitmapReader:
	247	+ def __init__(self):
	248	+ Publisher.subscribe(self.CancelLoad, "Cancel bitmap load")
	249	+
	250	+ def CancelLoad(self, evt_pubsub):
	251	+ self.running = False
	252	+ self.stoped = True
	253	+
	254	+ def SetWindowEvent(self, frame):
	255	+ self.frame = frame
	256	+
	257	+ def SetDirectoryPath(self, path,recursive=True):
	258	+ self.running = True
	259	+ self.stoped = False
	260	+ self.GetBitmaps(path,recursive)
	261	+
	262	+ def UpdateLoadFileProgress(self,cont_progress):
	263	+ Publisher.sendMessage("Update bitmap load", cont_progress)
	264	+
	265	+ def EndLoadFile(self, bitmap_list):
	266	+ Publisher.sendMessage("End bitmap load", bitmap_list)
	267	+
	268	+ def GetBitmaps(self, path, recursive):
	269	+
	270	+ #if not const.VTK_WARNING:
	271	+ # log_path = os.path.join(const.LOG_FOLDER, 'vtkoutput.txt')
	272	+ # fow = vtk.vtkFileOutputWindow()
	273	+ # fow.SetFileName(log_path)
	274	+ # ow = vtk.vtkOutputWindow()
	275	+ # ow.SetInstance(fow)
	276	+
	277	+ y = yGetBitmaps(path, recursive)
	278	+ for value_progress in y:
	279	+ if not self.running:
	280	+ break
	281	+ if isinstance(value_progress, tuple):
	282	+ self.UpdateLoadFileProgress(value_progress)
	283	+ else:
	284	+ self.EndLoadFile(value_progress)
	285	+
	286	+ #Is necessary in the case user cancel
	287	+ #the load, ensure that dicomdialog is closed
	288	+ if(self.stoped):
	289	+ self.UpdateLoadFileProgress(None)
	290	+ self.stoped = False
	291	+
	292	+def VtkErrorPNGWriter(obj, f):
	293	+ global vtk_error
	294	+ vtk_error = True
	295	+
	296	+def ScipyRead(filepath):
	297	+ try:
	298	+ r = misc.imread(filepath, flatten=True)
	299	+ dt = r.dtype
	300	+
	301	+ if dt == "float" or dt == "float16"\
	302	+ or dt == "float32" or dt == "float64":
	303	+ shift=-r.max()/2
	304	+ simage = numpy.zeros_like(r, dtype='int16')
	305	+ simage[:] = r.astype('int32') + shift
	306	+
	307	+ return simage
	308	+ else:
	309	+ return r
	310	+ except(IOError):
	311	+ return False
	312	+
	313	+def VtkRead(filepath, t):
	314	+
	315	+ global no_error
	316	+
	317	+ if t == "bmp":
	318	+ reader = vtk.vtkBMPReader()
	319	+
	320	+ elif t == "tiff" or t == "tif":
	321	+ reader = vtk.vtkTIFFReader()
	322	+
	323	+ elif t == "png":
	324	+ reader = vtk.vtkPNGReader()
	325	+
	326	+ elif t == "jpeg" or t == "jpg":
	327	+ reader = vtk.vtkJPEGReader()
	328	+
	329	+ else:
	330	+ return False
	331	+
	332	+ reader.AddObserver("ErrorEvent", VtkErrorToPy)
	333	+ reader.SetFileName(filepath)
	334	+ reader.Update()
	335	+
	336	+ if no_error:
	337	+ image = reader.GetOutput()
	338	+ dim = image.GetDimensions()
	339	+
	340	+ if reader.GetNumberOfScalarComponents() > 1:
	341	+ luminanceFilter = vtk.vtkImageLuminance()
	342	+ luminanceFilter.SetInputData(image)
	343	+ luminanceFilter.Update()
	344	+
	345	+ image = vtk.vtkImageData()
	346	+ image.DeepCopy(luminanceFilter.GetOutput())
	347	+
	348	+ img_array = numpy_support.vtk_to_numpy(image.GetPointData().GetScalars())
	349	+ img_array.shape = (dim[1], dim[0])
	350	+
	351	+ return img_array
	352	+ else:
	353	+ no_error = True
	354	+ return False
	355	+
	356	+
	357	+def ReadBitmap(filepath):
	358	+
	359	+ t = VerifyDataType(filepath)
	360	+
	361	+ if t == False:
	362	+ return False
	363	+
	364	+ img_array = VtkRead(filepath, t)
	365	+
	366	+ if not(isinstance(img_array, numpy.ndarray)):
	367	+
	368	+ no_error = True
	369	+
	370	+ img_array = ScipyRead(filepath)
	371	+
	372	+ if not(isinstance(img_array, numpy.ndarray)):
	373	+ return False
	374	+
	375	+ return img_array
	376	+
	377	+
	378	+def VtkErrorToPy(obj, evt):
	379	+ global no_error
	380	+ no_error = False
	381	+
	382	+
	383	+def VerifyDataType(filepath):
	384	+ try:
	385	+ t = imghdr.what(filepath)
	386	+ return t
	387	+ except IOError:
	388	+ return False
	389	+