diff --git a/invesalius/control.py b/invesalius/control.py
index b1520ab..9bdb703 100755
--- a/invesalius/control.py
+++ b/invesalius/control.py
@@ -9,6 +9,7 @@ import project as prj
 import data.imagedata_utils as utils
 import data.surface as surface
 import data.volume as volume
+import reader.dicom_grouper
 import gui.dialogs as dialog
 import reader.dicom_reader as dcm
 import reader.analyze_reader as analyze
@@ -23,23 +24,125 @@ class Controller():
         self.__bind_events()
 
     def __bind_events(self):
-        ps.Publisher().subscribe(self.ImportDirectory, 'Import directory')
+        ps.Publisher().subscribe(self.OnImportMedicalImages, 'Import directory')
         ps.Publisher().subscribe(self.StartImportPanel, "Load data to import panel")
         ps.Publisher().subscribe(self.LoadRaycastingPreset,
                                  'Load raycasting preset')
         ps.Publisher().subscribe(self.SaveRaycastingPreset,
                                  'Save raycasting preset')
+        ps.Publisher().subscribe(self.OnOpenDicomGroup,
+                                 'Open DICOM group')
 
     def StartImportPanel(self, pubsub_evt):
         # path to directory
         path = pubsub_evt.data
 
         # retrieve DICOM files splited into groups
-        dicom_series = dcm.GetDicomGroups(path)
-        ps.Publisher().sendMessage("Load import panel", dicom_series)
+        patient_series = dcm.GetDicomGroups(path)
+        ps.Publisher().sendMessage("Load import panel", patient_series)
+        first_patient = patient_series[0]
+        #ps.Publisher().sendMessage("Load dicom preview", first_patient)
+
+    def OnImportMedicalImages(self, pubsub_evt):
+        directory = pubsub_evt.data
+        self.ImportMedicalImages(directory)
+
+    def ImportMedicalImages(self, directory): 
+        # OPTION 1: DICOM?
+        patients_groups = dcm.GetDicomGroups(directory)
+        if len(patients_groups):
+            group = dcm.SelectLargerDicomGroup(patients_groups)
+            imagedata, dicom = self.OpenDicomGroup(group, gui=False)
+            self.CreateDicomProject(imagedata, dicom)
+        # OPTION 2: ANALYZE?
+        else:
+            imagedata = analyze.ReadDirectory(directory)
+            if imagedata:
+                self.CreateAnalyzeProject(imagedata)
+            # OPTION 3: Nothing...
+            else:
+                print "No medical images found on given directory"
+                return
+        self.LoadProject()
+
+    def LoadProject(self):
+        proj = prj.Project()
+        ps.Publisher().sendMessage('Set project name', proj.name)
+        ps.Publisher().sendMessage('Load slice to viewer', (proj.imagedata))
+        self.LoadImagedataInfo() # TODO: where do we insert this <<<?
+        ps.Publisher().sendMessage('Bright and contrast adjustment image',\
+                                   (proj.window, proj.level))
+        ps.Publisher().sendMessage('Update window level value',\
+                                    (proj.window, proj.level))
+        ps.Publisher().sendMessage('Show content panel')
+        ps.Publisher().sendMessage('Update AUI')
+
+    def CreateAnalyzeProject(self, imagedata):
+        proj = prj.Project()
+        proj.name = "Untitled"
+        proj.SetAcquisitionModality("MRI")
+        proj.imagedata = imagedata
+        #TODO: Verify if all Analyse are in AXIAL orientation
+        proj.original_orientation =  const.AXIAL
+        proj.threshold_range = imagedata.GetScalarRange()
+        proj.window = proj.threshold_range[1] - proj.threshold_range[0]
+        proj.level  (0.5 * (proj.threshold_range[1] + proj.threshold_range[0]))
+
+        const.THRESHOLD_OUTVALUE = proj.threshold_range[0]
+        const.THRESHOLD_INVALUE = proj.threshold_range[1]
+        const.WINDOW_LEVEL['Default'] = (proj.window, proj.level)
+        const.WINDOW_LEVEL['Manual'] = (proj.window, proj.level)
 
-        #ps.Publisher().sendMessage("Load dicom preview", series_preview)
 
+    def CreateDicomProject(self, imagedata, dicom):
+        name_to_const = {"AXIAL":const.AXIAL,
+                         "CORONAL":const.CORONAL,
+                         "SAGITTAL":const.SAGITAL}
+
+        proj = prj.Project()
+        proj.name = dicom.patient.name
+        proj.SetAcquisitionModality(dicom.acquisition.modality)
+        proj.imagedata = imagedata
+        proj.original_orientation =\
+                    name_to_const[dicom.image.orientation_label]
+        proj.window = float(dicom.image.window)
+        proj.level = float(dicom.image.level)
+        proj.threshold_range = imagedata.GetScalarRange()
+
+        const.THRESHOLD_OUTVALUE = proj.threshold_range[0]
+        const.THRESHOLD_INVALUE = proj.threshold_range[1]
+        const.WINDOW_LEVEL['Default'] = (proj.window, proj.level)
+        const.WINDOW_LEVEL['Manual'] = (proj.window, proj.level)
+
+    def OnOpenDicomGroup(self, pubsub_evt):
+        group = pubsub_evt.data
+        imagedata, dicom = self.OpenDicomGroup(group, gui=False)
+        self.CreateDicomProject(imagedata, dicom)
+        self.LoadProject()
+    
+    def OpenDicomGroup(self, dicom_group, gui=True):
+
+        # Retrieve general DICOM headers
+        dicom = dicom_group.GetDicomSample()
+
+        # Create imagedata
+        filelist = dicom_group.GetFilenameList()
+        zspacing = dicom_group.zspacing
+        imagedata = utils.CreateImageData(filelist, zspacing)
+
+        # 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 bellow"
+            value = -1*tilt_value
+            tilt_value = dialog.ShowNumberDialog(message, value)
+            imagedata = utils.FixGantryTilt(imagedata, tilt_value)
+        elif (tilt_value) and not (gui):
+            tilt_value = -1*tilt_value
+            imagedata = utils.FixGantryTilt(imagedata, tilt_value)
+
+        return imagedata, dicom
 
     def ImportDirectory(self, pubsub_evt=None, dir_=None):
         """
@@ -84,19 +187,20 @@ class Controller():
         else:
             "No DICOM files were found. Trying to read with ITK..."
             imagedata = analyze.ReadDirectory(dir_)
-            acquisition_modality = "MRI"
+            if imagedata:
+                acquisition_modality = "MRI"
 
-            #TODO: Verify if all Analyse is AXIAL orientation
-            orientation = const.AXIAL
+                #TODO: Verify if all Analyse is AXIAL orientation
+                orientation = const.AXIAL
 
-            proj.SetAcquisitionModality(acquisition_modality)
-            proj.imagedata = imagedata
-            proj.original_orientation = orientation
-            threshold_range = proj.imagedata.GetScalarRange()
-            proj.window = window = threshold_range[1] - threshold_range[0]
-            proj.level = level = (0.5 * (threshold_range[1] + threshold_range[0]))
+                proj.SetAcquisitionModality(acquisition_modality)
+                proj.imagedata = imagedata
+                proj.original_orientation = orientation
+                threshold_range = proj.imagedata.GetScalarRange()
+                proj.window = window = threshold_range[1] - threshold_range[0]
+                proj.level = level = (0.5 * (threshold_range[1] + threshold_range[0]))
             
-            ps.Publisher().sendMessage('Update window level value',\
+                ps.Publisher().sendMessage('Update window level value',\
                            (proj.window, proj.level))
 
         if not imagedata:
diff --git a/invesalius/data/imagedata_utils.py b/invesalius/data/imagedata_utils.py
index 5fd15b0..0a3038a 100644
--- a/invesalius/data/imagedata_utils.py
+++ b/invesalius/data/imagedata_utils.py
@@ -1,5 +1,8 @@
 import math
 import vtk
+import vtkgdcm
+
+import constants as const
 
 # TODO: Test cases which are originally in sagittal/coronal orientation
 # and have gantry
@@ -162,3 +165,52 @@ def ExtractVOI(imagedata,xi,xf,yi,yf,zi,zf):
     voi.SetSampleRate(1, 1, 1)
     voi.Update()  
     return voi.GetOutput()
+
+def CreateImageData(filelist, zspacing):
+
+    if not(const.REDUCE_IMAGEDATA_QUALITY):
+        array = vtk.vtkStringArray()
+        for x in xrange(len(filelist)):
+            array.InsertValue(x,filelist[x])
+
+        reader = vtkgdcm.vtkGDCMImageReader()
+        reader.SetFileNames(array)
+        reader.Update()
+
+        # The zpacing is a DicomGroup property, so we need to set it
+        imagedata = vtk.vtkImageData()
+        imagedata.DeepCopy(reader.GetOutput())
+        spacing = imagedata.GetSpacing()
+        imagedata.SetSpacing(spacing[0], spacing[1], zspacing)
+    else:
+        # Reformat each slice and future append them
+        appender = vtk.vtkImageAppend()
+        appender.SetAppendAxis(2) #Define Stack in Z
+
+        # Reformat each slice
+        for x in xrange(len(filelist)):
+            # TODO: We need to check this automatically according
+            # to each computer's architecture
+            # If the resolution of the matrix is too large
+            reader = vtkgdcm.vtkGDCMImageReader()
+            reader.SetFileName(filelist[x])
+            reader.Update()
+
+            #Resample image in x,y dimension
+            slice_imagedata = ResampleImage2D(reader.GetOutput(), 256)
+
+            #Stack images in Z axes
+            appender.AddInput(slice_imagedata)
+            appender.Update()
+
+        # The zpacing is a DicomGroup property, so we need to set it
+        imagedata = vtk.vtkImageData()
+        imagedata.DeepCopy(appender.GetOutput())
+        spacing = imagedata.GetSpacing()
+
+        imagedata.SetSpacing(spacing[0], spacing[1], zspacing)
+
+    imagedata.Update()
+    return imagedata
+
+
diff --git a/invesalius/gui/dicom_preview_panel.py b/invesalius/gui/dicom_preview_panel.py
index 6611cbb..d7d5829 100755
--- a/invesalius/gui/dicom_preview_panel.py
+++ b/invesalius/gui/dicom_preview_panel.py
@@ -31,6 +31,27 @@ class SerieEvent(PreviewEvent):
     def __init__(self , evtType, id):
         super(SerieEvent, self).__init__(evtType, id)
 
+class DicomImageData(object):
+    def __init__(self):
+        pass
+
+    def SetInput(self, dicom):
+        reader = vtkgdcm.vtkGDCMImageReader()
+        reader.SetFileName(dicom.image.file)
+        imagedata = reader.GetOutput()
+
+        scale = imagedata.GetScalarRange()
+        
+        cast = vtk.vtkImageMapToWindowLevelColors()
+        cast.SetInput(imagedata)
+        cast.SetWindow(float(dicom.image.window))
+        cast.SetLevel(float(dicom.image.level))
+
+        self.imagedata = cast.GetOutput()
+
+    def GetOutput(self):
+        return self.imagedata
+
 
 class DicomLoader(object):
     """
@@ -119,6 +140,15 @@ class Preview(wx.Panel):
     def SetSubtitle(self, subtitle):
         self.subtitle.SetLabel(subtitle)
 
+    def SetGroup(self, group):
+        self.SetTitle(group.title)
+        self.SetSubtitle("%d images"%(group.nslices))
+        d = DicomImageData()
+        d.SetInput(group.dicom)
+        imagedata = d.GetOutput()
+        self.actor.SetInput(imagedata)
+        self.render.ResetCamera()
+    
     def SetImage(self, image_data):
         """
         Set a Image to preview.
@@ -198,23 +228,23 @@ class DicomPreviewSeries(wx.Panel):
                        "%d Images" % len(self.series[i][0]), # Subtitle
                        i) for n, i in enumerate(self.series)]
 
-    def SetDicomSeries(self, files):
-        self.files = files
-        scroll_range = len(files)/5
-        if scroll_range * 5 < len(files):
+    def SetDicomSeries(self, patient):
+        #self.files = files
+        ngroups = patient.ngroups
+        self.groups = patient.GetGroups()
+        
+        scroll_range = ngroups/5
+        if scroll_range * 5 < ngroups:
             scroll_range +=1
         self.scroll.SetScrollbar(0, 3, scroll_range, 5)
         self._display_previews()
 
     def _display_previews(self):
-        initial = self.displayed_position * 5
-        final = initial + 15
-        for f, p in zip(self.files[initial:final], self.previews):
-            print "--------"
-            print "f:", f
-            print "p: ", p
-            p.SetImage(f)
-            p.Show()
+        begin = self.displayed_position * 5
+        end = begin + 15
+        for group, preview in zip(self.groups[begin:end], self.previews):
+            preview.SetGroup(group)
+            preview.Show()
 
     def OnScroll(self, evt):
         self.displayed_position = evt.GetPosition()
diff --git a/invesalius/gui/frame.py b/invesalius/gui/frame.py
index f00f28c..838ad69 100755
--- a/invesalius/gui/frame.py
+++ b/invesalius/gui/frame.py
@@ -80,6 +80,11 @@ class Frame(wx.Frame):
         ps.Publisher().subscribe(self.UpdateAui, "Update AUI")
         ps.Publisher().subscribe(self.ShowTask, 'Show task panel')
         ps.Publisher().subscribe(self.HideTask, 'Hide task panel')
+        ps.Publisher().subscribe(self.SetProjectName, 'Set project name')
+
+    def SetProjectName(self, pubsub_evt):
+        proj_name = pubsub_evt.data
+        self.SetTitle("InVesalius 3 - %s"%(proj_name))
 
     def UpdateAui(self, pubsub_evt):
         self.aui_manager.Update()
@@ -169,7 +174,9 @@ class Frame(wx.Frame):
 
     def ShowContentPanel(self, evt_pubsub):
         aui_manager = self.aui_manager
+        aui_manager.GetPane("Import").Show(0)
         aui_manager.GetPane("Data").Show(1)
+        aui_manager.GetPane("Tasks").Show(1)
         aui_manager.Update()
 
     def OnSize(self, evt):
diff --git a/invesalius/gui/import_panel.py b/invesalius/gui/import_panel.py
index 16f28c1..99fbbe0 100644
--- a/invesalius/gui/import_panel.py
+++ b/invesalius/gui/import_panel.py
@@ -130,21 +130,22 @@ class TextPanel(wx.Panel):
 
         tree.Expand(self.root)
         
-        tree.GetMainWindow().Bind(wx.EVT_RIGHT_UP, self.OnRightUp)
         tree.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnActivate)
 
     def OnActivate(self, evt):
         print "OnActivate"
         item = evt.GetItem()
-        print self.tree.GetItemPyData(item)
-        
-
-    def OnRightUp(self, evt):
-        pos = evt.GetPosition()
-        item, flags, col = self.tree.HitTest(pos)
-        if item:
-            print 'Flags: %s, Col:%s, Text: %s' %\
-                           (flags, col, self.tree.GetItemText(item, col))
+        group = self.tree.GetItemPyData(item)
+        if group:
+            print "send"
+            ps.Publisher().sendMessage('Open DICOM group',
+                                        group)
+
+        else:
+            if self.tree.IsExpanded(item):
+                self.tree.Collapse(item)
+            else:
+                self.tree.Expand(item)
 
     def OnSize(self, evt):
         self.tree.SetSize(self.GetSize())
diff --git a/invesalius/reader/dicom_grouper.py b/invesalius/reader/dicom_grouper.py
index df68851..ae541d4 100644
--- a/invesalius/reader/dicom_grouper.py
+++ b/invesalius/reader/dicom_grouper.py
@@ -51,6 +51,8 @@
 # <dicom.image.number> and <dicom.acquisition.series_number>
 # were swapped
 
+import gdcm
+
 ORIENT_MAP = {"SAGITTAL":0, "CORONAL":1, "AXIAL":2, "OBLIQUE":2}
 
 
@@ -96,7 +98,28 @@ class DicomGroup:
         # (interpolated)
         return self.slices_dict.values()
 
-    def GetSortedList(self):
+    def GetFilenameList(self):
+        # Should be called when user selects this group
+        # This list will be used to create the vtkImageData
+        # (interpolated)
+
+        filelist = [dicom.image.file for dicom in
+                self.slices_dict.values()]
+        
+        # Sort slices using GDCM
+        if (self.dicom.image.orientation_label <> "CORONAL"):
+            #Organize reversed image
+            sorter = gdcm.IPPSorter()
+            sorter.SetComputeZSpacing(True)
+            sorter.SetZSpacingTolerance(1e-10)
+            sorter.Sort(filelist)
+            filelist = sorter.GetFilenames()
+
+            #Getting organized image
+        return filelist
+
+
+    def GetHandSortedList(self):
         # This will be used to fix problem 1, after merging
         # single DicomGroups of same study_id and orientation
         list_ = self.slices_dict.values()
@@ -106,7 +129,7 @@ class DicomGroup:
         return list_
 
     def UpdateZSpacing(self):
-        list_ = self.GetSortedList()
+        list_ = self.GetHandSortedList()
         
         if (len(list_) > 1):
             dicom = list_[0]
@@ -246,7 +269,7 @@ class PatientGroup:
         group_counter = 0
         for group_key in dict_to_change:
             # 2nd STEP: SORT
-            sorted_list = dict_to_change[group_key].GetSortedList()
+            sorted_list = dict_to_change[group_key].GetHandSortedList()
 
             # 3rd STEP: CHECK DIFFERENCES
             axis = ORIENT_MAP[group_key[0]] # based on orientation
diff --git a/invesalius/reader/dicom_reader.py b/invesalius/reader/dicom_reader.py
index 1be99a4..ca72b43 100644
--- a/invesalius/reader/dicom_reader.py
+++ b/invesalius/reader/dicom_reader.py
@@ -28,32 +28,26 @@ import dicom
 import dicom_grouper
 import data.imagedata_utils as iu
 
-def LoadImages(dir_):
+def ReadDicomGroup(dir_):
 
     patient_group = GetDicomGroups(dir_)
-    filelist, dicom, zspacing = SelectLargerDicomGroup(patient_group)
-    filelist = SortFiles(filelist, dicom)
-    imagedata = CreateImageData(filelist, zspacing)
-    
-    return imagedata, dicom
+    if len(patient_group) > 0:
+        filelist, dicom, zspacing = SelectLargerDicomGroup(patient_group)
+        filelist = SortFiles(filelist, dicom)
+        imagedata = CreateImageData(filelist, zspacing)
+        return imagedata, dicom
+    else:
+        return False
 
 
 def SelectLargerDicomGroup(patient_group):
-    nslices_old = 0
+    maxslices = 0
     for patient in patient_group:
         group_list = patient.GetGroups()
         for group in group_list:
-            nslices = group.nslices
-            print "nslices:", nslices
-            if (nslices >= nslices_old):
-                dicoms = group.GetList()
-                zspacing = group.zspacing
-                nslices_old = nslices
-
-    filelist = []
-    for dicom in dicoms:
-        filelist.append(dicom.image.file)
-    return filelist, dicom, zspacing
+            if group.nslices > maxslices:
+                larger_group = group
+    return larger_group
 
 def SortFiles(filelist, dicom):
     # Sort slices
@@ -71,53 +65,6 @@ def SortFiles(filelist, dicom):
     return filelist
 
 
-def CreateImageData(filelist, zspacing):
-
-    if not(const.REDUCE_IMAGEDATA_QUALITY):
-        array = vtk.vtkStringArray()
-        for x in xrange(len(filelist)):
-            array.InsertValue(x,filelist[x])
-
-        reader = vtkgdcm.vtkGDCMImageReader()
-        reader.SetFileNames(array)
-        reader.Update()
-
-        # The zpacing is a DicomGroup property, so we need to set it
-        imagedata = vtk.vtkImageData()
-        imagedata.DeepCopy(reader.GetOutput())
-        spacing = imagedata.GetSpacing()
-        imagedata.SetSpacing(spacing[0], spacing[1], zspacing)
-    else:
-        # Reformat each slice and future append them
-        appender = vtk.vtkImageAppend()
-        appender.SetAppendAxis(2) #Define Stack in Z
-
-        # Reformat each slice
-        for x in xrange(len(filelist)):
-            # TODO: We need to check this automatically according
-            # to each computer's architecture
-            # If the resolution of the matrix is too large
-            reader = vtkgdcm.vtkGDCMImageReader()
-            reader.SetFileName(filelist[x])
-            reader.Update()
-
-            #Resample image in x,y dimension
-            slice_imagedata = iu.ResampleImage2D(reader.GetOutput(), 256)
-
-            #Stack images in Z axes
-            appender.AddInput(slice_imagedata)
-            appender.Update()
-
-        # The zpacing is a DicomGroup property, so we need to set it
-        imagedata = vtk.vtkImageData()
-        imagedata.DeepCopy(appender.GetOutput())
-        spacing = imagedata.GetSpacing()
-
-        imagedata.SetSpacing(spacing[0], spacing[1], zspacing)
-
-    imagedata.Update()
-    return imagedata
-
 
 def GetDicomGroups(directory, recursive=True):
     """
--
libgit2 0.21.2