コード例 #1
0
ファイル: video.py プロジェクト: kelwinfc/colposcopy
 def OnStop(self, event=None):
     self.is_running = False
     self.parent.representatives[self.index] = \
         self.previous_representative
     self.parent.update_representatives(False)
     self.play.SetBitmapLabel(wx.Bitmap(utils.media(self.config,
                                               "play")))
     if self.worker is not None:
         self.worker.abort()
         self.worker = None
コード例 #2
0
ファイル: video.py プロジェクト: kelwinfc/colposcopy
    def OnPlay(self, event):
        if self.parent.num_of_frames == 0:
            return

        if self.worker is None:
            self.is_running = True
            self.previous_representative = \
                self.parent.representatives[self.index]
            self.play.SetBitmapLabel(wx.Bitmap(utils.media(self.config,
                                                           "stop")))
            self.worker = VideoPlayer(self, self.parent, self.index)
        else:
            self.OnStop(event)
コード例 #3
0
ファイル: video.py プロジェクト: kelwinfc/colposcopy
    def setLayout(self, extra_values=[]):
        self.sizer = wx.BoxSizer(wx.VERTICAL)
        self.headerSizer = wx.BoxSizer(wx.HORIZONTAL)

        self.label = wx.StaticText(self, label=self.name)
        self.play = wx.BitmapButton(self, id=wx.ID_ANY,
                                    bitmap=wx.Bitmap(utils.media(self.config,
                                                                 "play")),
                                                     style=wx.NO_BORDER,
                                                     pos=(0, 0))

        self.headerSizer.Add(self.label, 0, wx.ALL, 0)
        self.headerSizer.Add(self.play, 0, wx.ALL, -1)

        self.img = wx.Bitmap(self.config["default"])
        self.img = self.parent.scale_image_size(self.img,
                                                0.24 * self.parent.width,
                                                0.24 * self.parent.height)
        self.img_bitmap = wx.StaticBitmap(self, -1, self.img)

        self.sizer.Add(self.headerSizer, 0, wx.ALL, 0)
        self.sizer.Add(self.img_bitmap, 0, wx.ALL, 0)
        self.SetSizer(self.sizer)
コード例 #4
0
ファイル: export.py プロジェクト: kelwinfc/colposcopy
    def setLayout(self, extra_values=[]):
        lsize = (0.30 * self.width, -1)
        
        font = wx.Font(pointSize=10, family=wx.FONTFAMILY_DECORATIVE,
                       style=wx.NORMAL, weight=wx.FONTWEIGHT_BOLD)

        self.sizer = wx.BoxSizer(wx.VERTICAL)
        
        self.title = wx.StaticText(self, wx.ID_ANY, label="Export Data")
        title_font = wx.Font(pointSize=12, family=wx.FONTFAMILY_DECORATIVE,
                             style=wx.NORMAL, weight=wx.FONTWEIGHT_BOLD)
        self.title.SetFont(title_font)

        self.sizer.Add(self.title, 0)
        self.sizer.Add(wx.StaticLine(self, wx.ID_ANY, size=lsize), 0)

        # Physician ID
        s = (0.15 * self.width, -1)
        self.physician = TextField(self, wx.ID_ANY, label="Physician ID",
                                   label_size=s, text_size=s, style=wx.TE_LEFT)
        self.sizer.Add(self.physician, 0, wx.TOP, 10)

        # Date
        self.dateSizer = wx.BoxSizer(wx.VERTICAL)
        self.date = CalendarCtrl(self, size=(0.22 * self.width, -1))
        self.dateSizer.Add(wx.StaticText(self, label="Assessment date"), 0)
        self.dateSizer.Add(self.date)
        self.sizer.Add(self.dateSizer, 0, wx.CENTER, 0)
        
        self.sizer.Add(wx.StaticLine(self, wx.ID_ANY, size=lsize), 0,
                       wx.TOP, 5)

        # Selective export
        self.personal = wx.CheckBox(self, label="Personal Information",
                                      style=wx.RB_GROUP)
        self.risk = wx.CheckBox(self, label="Risk Factors")
        
        self.colposcopy = wx.CheckBox(self, label="Colposcopy")
        self.representatives = wx.CheckBox(self, label="Chosen frames")
        self.macroscopic = wx.CheckBox(self, label="Macroscopic results")
        self.green = wx.CheckBox(self, label="Green results")
        self.hinselmann = wx.CheckBox(self, label="Hinselmann results")
        self.schiller = wx.CheckBox(self, label="Schiller Results")
        
        self.citology = wx.CheckBox(self, label="Citology Results")
        self.biopsy = wx.CheckBox(self, label="Biopsy Results")


        self.selectiveSizer = wx.GridSizer(13, 2, 0, 10)

        dummy = wx.Size(0, 0)
        for x in [wx.StaticText(self, label="Patient information"), dummy,
                  self.personal, self.risk,
                  dummy, dummy,
                  wx.StaticText(self, label="Colposcopy"), dummy,
                  self.colposcopy, self.representatives, 
                  self.macroscopic, self.green,
                  self.hinselmann, self.schiller,
                  dummy, dummy,
                  wx.StaticText(self, label="Citology"), dummy,
                  self.citology, dummy,
                  dummy, dummy,
                  wx.StaticText(self, label="Biopsy"), dummy,
                  self.biopsy, dummy]:
            if type(x) == wx.CheckBox:
                x.SetValue(True)
            self.selectiveSizer.Add(x, 0)
        
        self.sizer.Add(self.selectiveSizer, 0, wx.TOP, 10)

        self.sizer.Add(wx.StaticLine(self, wx.ID_ANY, size=lsize), 0,
                       wx.TOP, 10)

        # Filename
        self.fileSizer = wx.BoxSizer(wx.HORIZONTAL)
        self.fileLabel = wx.StaticText(self, label="Export")
        self.filenameButton = \
            wx.BitmapButton(self, bitmap=wx.Bitmap(utils.media(self.config,
                                                               "save")),
                            style=wx.NO_BORDER)

        self.fileSizer.Add(self.fileLabel, 0, wx.TOP, 5)
        self.fileSizer.Add(self.filenameButton, 0, wx.LEFT, 10)
        self.sizer.Add(self.fileSizer, 0, wx.TOP|wx.ALIGN_RIGHT, 10)

        self.SetSizer(self.sizer)
コード例 #5
0
 def rellenar_widgets(self):
     """
     Introduce la información del objeto actual
     en los widgets.
     No se chequea que sea != None, así que
     hay que tener cuidado de no llamar a 
     esta función en ese caso.
     """
     if self.objeto:
         self.wids['e_numalbaran'].set_text(self.objeto.numalbaran)
     referencias = {}    # Valores de referencia por producto.
     ## TODO: Refactorizar esto para sacar los cálculos de la capa vista.
     ##       Se debe poder calcular los valores de impresión desde 
     ##       cualquier parte de la aplicación sin tener que abrir esta 
     ##       ventana.
     # Rescato lotes y partidas.
     productos = {}
     for articulo in self.objeto.articulos:
         producto = articulo.productoVenta
         for atributo in ("lote", "loteCem", "partida", "partidaCem"):
             lote_o_partida = getattr(articulo, atributo)
             try:
                 if (lote_o_partida 
                     and lote_o_partida not in productos[producto]):
                     productos[producto].append(lote_o_partida)
             except KeyError:
                 productos[producto] = [lote_o_partida]
         # Valores de referencia.
         if producto.camposEspecificosRolloID:
             try:
                 fpar = articulo.partida.get_fecha_fabricacion()
                 cer = producto.camposEspecificosRollo.buscar_marcado(fpar)
                 if cer == None:
                     raise ValueError
             except (AttributeError, ValueError):
                 cer = producto.camposEspecificosRollo
             referencias[producto] = {
                 "Resistencia longitudinal": 
                     [cer.valorPruebaLongitudinalInf, 
                      cer.estandarPruebaLongitudinal, 
                      cer.valorPruebaLongitudinalSup],
                 "Alargamiento longitudinal": 
                     [cer.valorPruebaAlargamientoLongitudinalInf, 
                      cer.estandarPruebaAlargamientoLongitudinal, 
                      cer.valorPruebaAlargamientoLongitudinalSup], 
                 "Resistencia transversal": 
                     [cer.valorPruebaTransversalInf, 
                      cer.estandarPruebaTransversal, 
                      cer.valorPruebaTransversalSup], 
                 "Alargamiento transversal": 
                     [cer.valorPruebaAlargamientoTransversalInf, 
                      cer.estandarPruebaAlargamientoTransversal, 
                      cer.valorPruebaAlargamientoTransversalSup], 
                 "Resistencia a la compresión": 
                     [cer.valorPruebaCompresionInf, 
                      cer.estandarPruebaCompresion, 
                      cer.valorPruebaCompresionSup], 
                 "Perforación": 
                     [cer.valorPruebaPerforacionInf, 
                      cer.estandarPruebaPerforacion, 
                      cer.valorPruebaPerforacionSup], 
                 "Espesor": 
                     [cer.valorPruebaEspesorInf, 
                      cer.estandarPruebaEspesor,  
                      cer.valorPruebaEspesorSup], 
                 "Permeabilidad": 
                     [cer.valorPruebaPermeabilidadInf, 
                      cer.estandarPruebaPermeabilidad, 
                      cer.valorPruebaPermeabilidadSup], 
                 "Apertura de poros": 
                     [cer.valorPruebaPorosInf, 
                      cer.estandarPruebaPoros, 
                      cer.valorPruebaPorosSup], 
                 "Gramaje": 
                     [cer.valorPruebaGramajeInf, 
                      cer.estandarPruebaGramaje, 
                      cer.valorPruebaGramajeSup], 
                 "Punzonado piramidal": 
                     [cer.valorPruebaPiramidalInf, 
                      cer.estandarPruebaPiramidal, 
                      cer.valorPruebaPiramidalSup]} 
         elif producto.camposEspecificosBalaID:
             ceb = producto.camposEspecificosBala
             referencias[producto] = {
                 "Media título": [ceb.dtex, 
                                  ceb.dtex, 
                                  ceb.dtex]}   # Es el único valor que se 
                                               # puede comparar.
     # Calculo medias.
     valores = {}
     for p in productos:
         valores[p] = {}
         for lote_o_partida in productos[p]:
             if isinstance(lote_o_partida, pclases.Lote):
                 descripciones_campo = (("Tenacidad", "tenacidad"), 
                                        ("Elongación", "elongacion"), 
                                        ("Encogimiento", "encogimiento"),
                                        ("% Grasa", "grasa"), 
                                        ("Media título", "mediatitulo"))
             elif isinstance(lote_o_partida, pclases.LoteCem):
                 descripciones_campo = (("Tenacidad", "tenacidad"), 
                                        ("Elongación", "elongacion"), 
                                        ("Encogimiento", "encogimiento"),
                                        ("% Grasa", "grasa"), 
                                        ("% Humedad", "humedad"), 
                                        ("Media título", "mediatitulo"))
             elif isinstance(lote_o_partida, pclases.Partida):
                 descripciones_campo = (("Gramaje", "gramaje"), 
                             ("Resistencia longitudinal", "longitudinal"), 
                             ("Alargamiento longitudinal", "alongitudinal"), 
                             ("Resistencia transversal", "transversal"), 
                             ("Alargamiento transversal", "atransversal"), 
                             ("Resistencia a la compresión", "compresion"), 
                             ("Perforación", "perforacion"), 
                             ("Espesor", "espesor"), 
                             ("Permeabilidad", "permeabilidad"), 
                             ("Apertura de poros", "poros"), 
                             ("Punzonado piramidal", "piramidal")) 
             elif isinstance(lote_o_partida, pclases.PartidaCem):
                 descripciones_campo = []
             for descripcion, campo in descripciones_campo:
                 valor = getattr(lote_o_partida, campo)
                 if valor is None or not lote_o_partida.esta_analizada():
                     # DONE: En teoría si no está analizada debería buscar 
                     # la partida anterior o posterior del mismo producto 
                     # que estuviera analizada (jmadrid). 
                     # Al final no. Me ha enviado otro correo con el nuevo 
                     # criterio para la impresión de valores nulos.
                     continue    # Ignoro valores nulos.
                 try:
                     valores[p][descripcion].append(valor)
                 except KeyError:
                     valores[p][descripcion] = [valor]
     # Y ahora sustituyo la lista de valores por su media:
     for p in valores:
         for campo in valores[p]:
             valores[p][campo] = utils.media(valores[p][campo])
     self.rellenar_tabla_datos(valores, referencias)
     self.rellenar_info_albaran(productos)
     self.wids['tv_datos'].expand_all()
コード例 #6
0
ファイル: video.py プロジェクト: kelwinfc/colposcopy
    def setLayout(self, extra_values=[]):
        # Sizers
        self.globalSizer = wx.BoxSizer(wx.VERTICAL)
        self.sizer = wx.BoxSizer(wx.VERTICAL)
        self.subSizer = wx.BoxSizer(wx.HORIZONTAL)
        self.leftSizer = wx.BoxSizer(wx.VERTICAL)
        self.rightSizer = wx.BoxSizer(wx.VERTICAL)
        self.fileSizer = wx.BoxSizer(wx.HORIZONTAL)

        self.framesSizer = wx.BoxSizer(wx.VERTICAL)
        self.topFramesSizer = wx.BoxSizer(wx.HORIZONTAL)
        self.bottomFramesSizer = wx.BoxSizer(wx.HORIZONTAL)

        self.globalSizer.AddStretchSpacer(1)
        self.globalSizer.Add(self.sizer, 0, wx.ALIGN_CENTER, 0)
        self.globalSizer.AddStretchSpacer(1)

        self.sizer.Add(self.fileSizer, 0, wx.ALL | wx.CENTER, 10)
        self.sizer.Add(self.subSizer, 0, wx.ALL | wx.CENTER, 10)

        self.subSizer.Add(self.leftSizer, 0, wx.TOP, 0)
        self.subSizer.Add(self.rightSizer, 0, wx.TOP, 0)

        # Input file
        self.fileLabel = wx.StaticText(self, label="Video:")
        self.fileInput = wx.TextCtrl(self,
                                     value="",
                                     size=(0.4 * self.width, -1),
                                     style=wx.TE_LEFT)
        self.videoFilenameButton = \
            wx.BitmapButton(self, id=wx.ID_ANY,
                            bitmap=wx.Bitmap(utils.media(self.config,
                                                         "video")),
                                             style=wx.NO_BORDER,
                                             pos=(0, 0))

        self.fileSizer.Add(self.fileLabel, 0, wx.TOP, 5)
        self.fileSizer.Add(self.fileInput, 0, wx.ALL, 0)
        self.fileSizer.Add(self.videoFilenameButton, 0, wx.ALL, 0)

        # Video
        self.imageLabel = wx.StaticText(self, label="Video Preview:")
        self.image = wx.Bitmap(self.config["default"])
        self.scale_image()
        self.imageControl = wx.StaticBitmap(self, -1, self.image)
        self.leftSizer.Add(self.imageLabel, 0, wx.TOP, 2)
        self.leftSizer.Add(self.imageControl, 0, wx.TOP, 5)

        # Colors and Tracker
        self.colors = wx.Bitmap(self.config["default"])
        self.colors = self.scale_image_size(self.colors,
                                            int(0.4 * self.width), 20)
        self.colorsImg = wx.StaticBitmap(self, -1, self.colors)

        self.tracker = wx.Slider(self, id=wx.ID_ANY, value=0, minValue=0,
                                 maxValue=0, size=(int(0.4 * self.width) + 10,
                                                   20),
                                 style=wx.SL_HORIZONTAL | wx.SL_AUTOTICKS)

        self.boundariesImg = self.empty_boundaries_img()
        self.topBoundariesMarkers = wx.StaticBitmap(self, -1,
                                                    self.boundariesImg)
        self.bottomBoundariesMarkers = wx.StaticBitmap(self, -1,
                                                       self.boundariesImg)

        # Controllers
        self.controllerSizer = wx.BoxSizer(wx.HORIZONTAL)
        self.stageLabel = wx.StaticText(self, label="Stage:")
        self.stageChoice = wx.Choice(self, id=wx.ID_ANY,
                                     choices=["Macroscopic", "Green",
                                              "Hinselmann", "Schiller"])
        self.stageSetLast = wx.Button(self, wx.ID_ANY,
                                      label="Set Last Frame")
        self.stageSetRepresentative = wx.Button(self, wx.ID_ANY,
                                      label="Set Representative")

        self.controllerSizer.Add(self.stageLabel, 0, wx.ALL, 5)
        self.controllerSizer.Add(self.stageChoice, 0, wx.LEFT, 0)
        self.controllerSizer.Add(self.stageSetLast, 0, wx.LEFT, 10)
        self.controllerSizer.Add(self.stageSetRepresentative, 0, wx.LEFT, 10)

        self.leftSizer.Add(self.tracker, 0, wx.LEFT, -5)
        self.leftSizer.Add(self.topBoundariesMarkers, 0, wx.TOP, 10)
        self.leftSizer.Add(self.colorsImg, 0, wx.TOP, 2)
        self.leftSizer.Add(self.bottomBoundariesMarkers, 0, wx.TOP, 2)
        self.leftSizer.Add(self.controllerSizer, 0, wx.TOP | wx.CENTER, 20)

        # Chosen frames
        self.macro = FrameWidget(self, "Macroscopic", 0, wx.ID_ANY)
        self.green = FrameWidget(self, "Green", 1, wx.ID_ANY)
        self.hinselmann = FrameWidget(self, "Hinselmann", 2, wx.ID_ANY)
        self.schiller = FrameWidget(self, "Schiller", 3, wx.ID_ANY)
        self.frames = [self.macro, self.green, self.hinselmann, self.schiller]
        self.boundaries = [0, 0, 0]
        self.representatives = [None, None, None, None]
        self.previous_representatives = [None, None, None, None]
        self.topFramesSizer.Add(self.macro, 0, wx.LEFT, 5)
        self.topFramesSizer.Add(self.green, 0, wx.LEFT, 10)
        self.bottomFramesSizer.Add(self.hinselmann, 0, wx.LEFT, 5)
        self.bottomFramesSizer.Add(self.schiller, 0, wx.LEFT, 10)

        self.rightSizer.Add(self.framesSizer)
        self.framesSizer.Add(self.topFramesSizer)
        self.framesSizer.Add(self.bottomFramesSizer, 0, wx.TOP, 5)

        self.rightSizer.Add(wx.StaticLine(self, size=(0.48 * self.width, -1)),
                            0, wx.ALL, 10)

        self.ts_progress = wx.StaticText(self, label="",
                                         size=(0.4 * self.width, -1))
        font = wx.Font(pointSize=14, family=wx.FONTFAMILY_DECORATIVE,
                           style=wx.NORMAL, weight=wx.FONTWEIGHT_BOLD)
        self.ts_progress.SetFont(font)

        self.ts_statistics = wx.GridSizer(3, 4, 10, 0)

        self.statisticsSizer = wx.BoxSizer(wx.VERTICAL)
        self.statisticsSizer.Add(self.ts_progress, 0, wx.LEFT, 10)
        self.statisticsSizer.Add(self.ts_statistics, 0, wx.ALL, 10)

        self.rightSizer.Add(self.statisticsSizer, 0,
                            wx.TOP | wx.ALIGN_CENTER, 0)

        self.SetSizer(self.globalSizer)