diff options
| author | pgperui <pgperui@65703dd9-322d-4ecd-a169-f49c4620ba53> | 2011-06-17 20:18:30 (GMT) |
|---|---|---|
| committer | pgperui <pgperui@65703dd9-322d-4ecd-a169-f49c4620ba53> | 2011-06-17 20:18:30 (GMT) |
| commit | 59b0ac8e4c791b31f33377bf2e04187bf9a984f0 (patch) | |
| tree | 89936d188b61ebf21ebfbc17edc744259c9a8351 | |
| parent | fb5b0b7edb546a542bcac8b9edfe75cf7f2c3e90 (diff) | |
git-svn-id: svn+ssh://lulu.fing.edu.uy/ens/home01/pgperui/repoSVN@183 65703dd9-322d-4ecd-a169-f49c4620ba53
| -rw-r--r-- | Utilidades/bin/python/CalibradorColor.py | 189 | ||||
| -rw-r--r-- | Utilidades/bin/python/Data/MarkersCalibradorColor.dat | 50 | ||||
| -rwxr-xr-x | Utilidades/bin/python/Data/camera_para.dat | bin | 0 -> 136 bytes | |||
| -rwxr-xr-x | Utilidades/bin/python/Data/patt.b | 196 | ||||
| -rwxr-xr-x | Utilidades/bin/python/Data/patt.c | 196 | ||||
| -rwxr-xr-x | Utilidades/bin/python/Data/patt.d | 196 | ||||
| -rwxr-xr-x | Utilidades/bin/python/Data/patt.f | 196 | ||||
| -rwxr-xr-x | Utilidades/bin/python/Data/patt.g | 196 | ||||
| -rw-r--r-- | Utilidades/bin/python/PuiModule.py | 351 | ||||
| -rw-r--r-- | Utilidades/bin/python/PuiModule.pyc | bin | 0 -> 35944 bytes | |||
| -rw-r--r-- | Utilidades/bin/python/Pui_wrap.cxx | 9772 |
11 files changed, 11342 insertions, 0 deletions
diff --git a/Utilidades/bin/python/CalibradorColor.py b/Utilidades/bin/python/CalibradorColor.py new file mode 100644 index 0000000..e99c263 --- /dev/null +++ b/Utilidades/bin/python/CalibradorColor.py @@ -0,0 +1,189 @@ +#! /usr/bin/env python +import pygame, sys, os, time +import PuiModule +from pygame import * + +vconf = "v4l2src device=/dev/video0 ! videorate ! video/x-raw-yuv,width=320,height=240,framerate=5/1 ! ffmpegcolorspace ! capsfilter caps=video/x-raw-rgb,bpp=24 ! identity name=artoolkit ! fakesink" +count = 0 +config_nameCalibrador = "Data/MarkersCalibradorColor.dat" +rangosEscalaColor = PuiModule.RangosColorApuntador +usarAlgoritmoRapido = 1 +mostrarDebugAR = 0 +aplicarMascara = 0 +frameSize = (320,240) + +h_bins = 30 #El histograma de HUE lo dividimos en 30 partes iguales +s_bins = 20 #El histograma de SATURATION lo dividimos en 20 partes iguales +v_bins = 20 #El histograma de BRIGHTNESS lo dividimos en 20 partes iguales + +id_marcador =0 +tipoMascara = PuiModule.TIPO_MASCARA_BINARIA +err_deteccion = 0 + +cantidad_muestras= 6 +res_aplicar_mascara = 0 +muestra = 0 + +aplicar_mascara=1 +aplicar_nueva_mascara=1 +tomar_muestra=0 +thresh = 100 +factorProporcionMaximoH = 10 +porcentajeMinimoRuido = 7 + +pui = None +dataImagen = None + +running = True + +#Variables de pantalla +size = (640,480) +screen = pygame.display.set_mode(size) +surface = pygame.display.get_surface() + +def initRangosColor(): + rangosEscalaColor.hmin = 1 #Teoricamente seria correcto que hmin fuera 0. Lo ponemos en 1 + rangosEscalaColor.hmax = 360 #Porque los negros totales y los blancos totales son convertidos + rangosEscalaColor.smin = 0 #con H=0 y eso lleva a que se introduzca ruido en el histograma + rangosEscalaColor.smax = 100 + rangosEscalaColor.vmin = 0 + rangosEscalaColor.vmax = 100 + +def desplegarRangosColor(rangos): + print '--------Rangos de Color--------\n' + print 'Hue: ['+rangos.hmin+','+rangos.hmax+']\n' + print 'Saturation: ['+rangos.smin+','+rangos.smax+']\n' + print 'Brightness: ['+rangos.vmin+','+rangos.vmax+']\n' + print '--------------------------------\n' + +def desplegarDataImage(imageData): + global running,screen,frameSize,aplicar_mascara,aplicar_nueva_mascara,tipoMascara,pui,mostrarDebugAR,tomar_muestra + print '14' + pg_img = pygame.image.frombuffer(imageData,frameSize, "RGB") + print '15' + screen.blit(pg_img, (0,0)) + pygame.display.flip() + print '16' + for event in pygame.event.get(): + if event.type == pygame.QUIT: + running = False + elif event.type == pygame.KEYDOWN: + if event.key == pygame.K_ESCAPE: + running = False + elif event.key == K_a: #aplicar mascara + aplicar_mascara = 1 - aplicar_mascara + elif event.key == K_n: #nueva mascara + aplicar_nueva_mascara = 1 - aplicar_nueva_mascara; + aplicar_mascara = 1; + elif event.key == K_u: #tipo de mascara + if tipoMascara==PuiModule.TIPO_MASCARA_BINARIA : + tipoMascara=PuiModule.TIPO_MASCARA_ATENUANTE + print 'Usando mascara ATENUANTE!\n' + else: + tipoMascara=PuiModule.TIPO_MASCARA_BINARIA; + print 'Usando mascara BINARIA!\n' + elif event.key == K_t: #set threshold + print '*** %s (frame/sec)\n' % (pui.getFPS()) + print 'Threshold Actual = %s' % ( pui.getARThreshold() ) + user_input = input('*************** Ingrese nuevo Threshold ******************') + print 'Threshold ingresado = %s' % (user_input) + pui.setARThreshold(user_input); + + elif event.key == K_d: #set debug image + mostrarDebugAR = 1 - mostrarDebugAR + pui.desplegarImagenAR(mostrarDebugAR) + elif event.key == K_RETURN: + tomar_muestra = 1 + aplicar_nueva_mascara = 1 - aplicar_nueva_mascara + aplicar_mascara = 1 + else: + print 'Evento desconocido!' + + + +def calibrar(): + global tomar_muestra,pui, id_marcador, muestra, aplicar_mascara, aplicar_nueva_mascara, tipoMascara, mostrarDebugAR + + print '7\n' + if tomar_muestra: + print 'Tomo la muestra!!!!!\n' + err_tomarMuestra = pui.tomarMuestraApuntador() + if err_tomarMuestra==PuiModule.ERROR_TOMAR_MUESTRA_FORMA_NO_IMPLEMENTADA: + sys.stderr.write("Error, no se pudo tomar muestra. Forma no implementada\n") + elif err_tomarMuestra==PuiModule.ERROR_TOMAR_MUESTRA_OK: + print 'Muestra tomada OK\n' + + tomar_muestra=0 + id_marcador+=1 + muestra+=1 + else: + print '8\n' + dataImagen = pui.capturarPyImageAR() + print '9\n' + if aplicar_mascara: + if aplicar_nueva_mascara: #Calculo la nueva mascara y la aplico + print '10\n' + err_deteccion = pui.detectarYCalcularPosicionTodosMultiMarkers() + print '11\n' + if err_deteccion==PuiModule.DETECCION_CORRECTA: + res_aplicar_mascara = pui.aplicarNuevaMascaraCalibrador(id_marcador,tipoMascara) + print pui.getFPSAndResetCount() + if res_aplicar_mascara==PuiModule.MASCARA_APLICADA: + print 'Se aplico la mascara correctamente\n' + aplicar_nueva_mascara = 0 + else: + print '12\n' + print 'err_deteccion= ' + print err_deteccion + print '\n13\n' + + else: #No calculo nueva mascara pero la aplico + pui.aplicarMascaraCalibrador(tipoMascara); + +# pui.desplegarImagenAR(mostrarDebugAR) + if not dataImagen == None: + desplegarDataImage(dataImagen.data) + print '15' + pui.capNext() + + + +def main(): + global pui, aplicar_mascara,aplicar_nueva_mascara,tomar_muestra,muestra,cantidad_muestras,jugar,factorProporcionMaximoH,porcentajeMinimoRuido,running + + aplicar_mascara=1 + aplicar_nueva_mascara=1 + tomar_muestra = 0 + pui = PuiModule.Pui() + initRangosColor() + pui.getModuleInfo() + print '1\n' + + pui.initPuiConCapturaDeVideo(PuiModule.MODO_MULTI_MARKERS_CALIBRADOR,"",config_nameCalibrador,"Data/camera_para.dat",vconf,usarAlgoritmoRapido,pui.NORMAL_SPEED_LOOP,1.0); + #pui.initARConVideo(config_nameCalibrador,"Data/camera_para.dat",vconf,usarAlgoritmoRapido,pui.NORMAL_SPEED_LOOP,1.0) + print '2\n' + pui.abrirVentanaGrafica() + + pui.capStart() + pui.initPropiedadesCalibracionSoloApuntador(PuiModule.FORMA_APUNTADOR_CIRCULO,1,360,0,100,0,100,h_bins,s_bins,v_bins,1) + print '3\n' + pui.setDebugCalibracion(False) + print '4\n' + pui.capStart() + print '5\n' + + while running: + if muestra<cantidad_muestras : + print '6\n' + calibrar() + elif not jugar : + print 'se tomaron todas las muestras\n se calculan los resultados....\n' + pui.calcularResultadosCalibracionApuntador(factorProporcionMaximoH,porcentajeMinimoRuido) + desplegarRangosColor(pui.getResultadosRangosColor()) + print 'fin de la calibracion' + jugar=1 + else: + print 'Jugando' + +if __name__ == "__main__": + main() diff --git a/Utilidades/bin/python/Data/MarkersCalibradorColor.dat b/Utilidades/bin/python/Data/MarkersCalibradorColor.dat new file mode 100644 index 0000000..7c16e11 --- /dev/null +++ b/Utilidades/bin/python/Data/MarkersCalibradorColor.dat @@ -0,0 +1,50 @@ +#the number of patterns to be recognized +6 + +#marker 1 +Data/patt.a +40.0 +0 0 +1 0 0 0 +0 1 0 0 +0 0 1 0 + +#marker 2 +Data/patt.b +40.0 +0 0 +1 0 0 100 +0 1 0 0 +0 0 1 0 + +#marker 3 +Data/patt.c +40.0 +0 0 +1 0 0 200 +0 1 0 0 +0 0 1 0 + +#marker 4 +Data/patt.d +40.0 +0 0 +1 0 0 0 +0 1 0 -100 +0 0 1 0 + +#marker 5 +Data/patt.g +40.0 +0 0 +1 0 0 100 +0 1 0 -100 +0 0 1 0 + +#marker 6 +Data/patt.f +40.0 +0 0 +1 0 0 200 +0 1 0 -100 +0 0 1 0 diff --git a/Utilidades/bin/python/Data/camera_para.dat b/Utilidades/bin/python/Data/camera_para.dat Binary files differnew file mode 100755 index 0000000..eb671b1 --- /dev/null +++ b/Utilidades/bin/python/Data/camera_para.dat diff --git a/Utilidades/bin/python/Data/patt.b b/Utilidades/bin/python/Data/patt.b new file mode 100755 index 0000000..722aef4 --- /dev/null +++ b/Utilidades/bin/python/Data/patt.b @@ -0,0 +1,196 @@ + 108 140 120 113 122 110 115 120 120 122 132 140 143 144 144 137 + 123 155 128 51 20 20 48 72 46 29 39 68 150 159 160 148 + 118 164 167 75 15 16 86 163 147 72 12 12 72 159 160 160 + 119 162 161 68 4 4 69 148 160 137 26 13 20 134 156 150 + 118 172 164 85 14 16 78 153 160 155 51 7 2 109 154 148 + 108 156 152 80 12 12 67 149 158 118 28 15 24 136 160 160 + 122 168 176 88 14 10 53 122 120 44 22 42 106 159 157 152 + 120 160 157 76 12 16 41 76 54 18 40 102 152 160 160 157 + 132 172 159 75 4 13 88 148 136 84 33 30 40 136 152 124 + 116 155 154 80 16 18 88 161 160 168 80 24 16 76 146 144 + 128 166 164 80 13 4 60 152 160 168 91 15 16 28 150 141 + 107 160 172 90 16 12 77 153 160 164 62 11 10 36 155 143 + 123 164 161 77 14 8 60 150 160 146 34 16 16 76 144 141 + 106 156 150 64 20 16 41 106 116 61 4 32 77 144 151 136 + 127 138 102 86 74 70 65 89 80 78 112 126 142 156 157 148 + 116 132 120 112 120 118 120 126 116 115 105 109 116 112 116 108 + 118 144 128 120 126 115 114 120 120 114 128 132 129 129 124 110 + 113 142 108 41 24 28 56 72 40 31 46 66 138 144 144 132 + 110 152 147 62 10 12 75 148 140 72 18 18 72 143 144 136 + 107 152 148 74 12 16 77 145 144 129 22 16 15 126 144 142 + 112 156 148 72 6 8 69 145 148 127 30 16 10 120 144 144 + 116 158 148 70 8 8 69 145 148 94 18 15 24 132 144 144 + 114 152 148 72 10 10 65 128 124 44 15 30 94 144 144 144 + 111 150 148 70 12 16 32 66 48 18 42 98 140 144 144 138 + 101 150 148 75 14 13 74 134 120 60 21 30 52 136 144 120 + 115 157 148 74 12 14 73 146 146 136 46 10 16 76 138 126 + 103 152 148 75 15 12 72 146 152 150 73 12 16 40 148 126 + 123 160 148 72 12 10 75 147 144 148 54 12 16 34 141 131 + 106 154 148 72 14 16 75 147 144 127 25 16 16 72 144 127 + 122 148 145 58 15 14 38 98 100 57 4 29 76 138 144 134 + 108 112 86 70 58 58 59 80 67 64 98 114 140 144 144 129 + 104 130 126 112 132 124 118 118 114 118 112 113 119 108 112 103 + 100 124 112 109 116 104 112 120 117 114 122 124 127 127 125 125 + 112 137 108 40 20 24 50 72 36 28 40 72 138 144 146 140 + 114 152 147 70 13 6 65 140 136 66 18 18 72 144 144 144 + 118 158 160 72 4 4 66 152 144 125 23 16 20 126 144 138 + 112 156 152 75 14 14 74 147 144 139 36 7 9 115 145 144 + 109 152 160 76 12 8 71 156 150 102 19 3 28 140 146 135 + 110 152 148 73 12 14 65 124 120 48 16 27 94 144 144 150 + 108 154 150 78 8 8 30 63 42 10 35 96 140 144 144 141 + 117 154 146 69 10 13 72 130 112 70 22 24 40 134 144 126 + 101 151 148 74 6 2 73 145 144 140 54 16 16 80 136 121 + 116 159 148 67 13 16 74 146 144 148 74 13 16 28 142 129 + 100 140 148 81 16 12 73 145 144 152 64 16 16 42 141 123 + 111 146 145 61 12 12 73 145 145 132 25 14 8 76 144 134 + 106 152 145 58 16 10 45 110 112 57 4 22 61 138 144 128 + 121 140 104 78 60 60 63 90 80 73 90 110 133 144 144 136 + 104 140 126 112 120 118 116 130 126 126 108 108 107 112 120 105 + + 137 148 160 150 148 160 152 157 124 144 141 143 141 136 148 108 + 144 160 160 156 154 160 157 160 152 146 150 155 144 151 157 116 + 144 159 159 134 109 136 159 160 136 76 28 36 76 144 156 112 + 143 150 72 20 2 24 106 152 40 16 16 10 16 77 142 116 + 140 68 12 13 7 15 42 102 30 24 15 11 16 32 126 109 + 132 39 12 26 51 28 22 40 33 80 91 62 34 4 112 105 + 122 29 72 137 155 118 44 18 84 168 168 164 146 61 78 115 + 120 46 147 160 160 158 120 54 136 160 160 160 160 116 80 116 + 120 72 163 148 153 149 122 76 148 161 152 153 150 106 89 126 + 115 48 86 69 78 67 53 41 88 88 60 77 60 41 65 120 + 110 20 16 4 16 12 10 16 13 18 4 12 8 16 70 118 + 122 20 15 4 14 12 14 12 4 16 13 16 14 20 74 120 + 113 51 75 68 85 80 88 76 75 80 80 90 77 64 86 112 + 120 128 167 161 164 152 176 157 159 154 164 172 161 150 102 120 + 140 155 164 162 172 156 168 160 172 155 166 160 164 156 138 132 + 108 123 118 119 118 108 122 120 132 116 128 107 123 106 127 116 + 110 132 136 142 144 144 144 138 120 126 126 131 127 134 129 103 + 124 144 144 144 144 144 144 144 144 138 148 141 144 144 144 112 + 129 144 143 126 120 132 144 144 136 76 40 34 72 138 144 108 + 129 138 72 15 10 24 94 140 52 16 16 16 16 76 140 119 + 132 66 18 16 16 15 30 98 30 10 12 12 16 29 114 113 + 128 46 18 22 30 18 15 42 21 46 73 54 25 4 98 112 + 114 31 72 129 127 94 44 18 60 136 150 148 127 57 64 118 + 120 40 140 144 148 148 124 48 120 146 152 144 144 100 67 114 + 120 72 148 145 145 145 128 66 134 146 146 147 147 98 80 118 + 114 56 75 77 69 69 65 32 74 73 72 75 75 38 59 118 + 115 28 12 16 8 8 10 16 13 14 12 10 16 14 58 124 + 126 24 10 12 6 8 10 12 14 12 15 12 14 15 58 132 + 120 41 62 74 72 70 72 70 75 74 75 72 72 58 70 112 + 128 108 147 148 148 148 148 148 148 148 148 148 148 145 86 126 + 144 142 152 152 156 158 152 150 150 157 152 160 154 148 112 130 + 118 113 110 107 112 116 114 111 101 115 103 123 106 122 108 104 + 125 140 144 138 144 135 150 141 126 121 129 123 134 128 136 105 + 125 146 144 144 145 146 144 144 144 136 142 141 144 144 144 120 + 127 144 144 126 115 140 144 144 134 80 28 42 76 138 144 112 + 127 138 72 20 9 28 94 140 40 16 16 16 8 61 133 107 + 124 72 18 16 7 3 27 96 24 16 13 16 14 22 110 108 + 122 40 18 23 36 19 16 35 22 54 74 64 25 4 90 108 + 114 28 66 125 139 102 48 10 70 140 148 152 132 57 73 126 + 117 36 136 144 144 150 120 42 112 144 144 144 145 112 80 126 + 120 72 140 152 147 156 124 63 130 145 146 145 145 110 90 130 + 112 50 65 66 74 71 65 30 72 73 74 73 73 45 63 116 + 104 24 6 4 14 8 14 8 13 2 16 12 12 10 60 118 + 116 20 13 4 14 12 12 8 10 6 13 16 12 16 60 120 + 109 40 70 72 75 76 73 78 69 74 67 81 61 58 78 112 + 112 108 147 160 152 160 148 150 146 148 148 148 145 145 104 126 + 124 137 152 158 156 152 152 154 154 151 159 140 146 152 140 140 + 100 112 114 118 112 109 110 108 117 101 116 100 111 106 121 104 + + 108 116 112 116 109 105 115 116 126 120 118 120 112 120 132 116 + 148 157 156 142 126 112 78 80 89 65 70 74 86 102 138 127 + 136 151 144 77 32 4 61 116 106 41 16 20 64 150 156 106 + 141 144 76 16 16 34 146 160 150 60 8 14 77 161 164 123 + 143 155 36 10 11 62 164 160 153 77 12 16 90 172 160 107 + 141 150 28 16 15 91 168 160 152 60 4 13 80 164 166 128 + 144 146 76 16 24 80 168 160 161 88 18 16 80 154 155 116 + 124 152 136 40 30 33 84 136 148 88 13 4 75 159 172 132 + 157 160 160 152 102 40 18 54 76 41 16 12 76 157 160 120 + 152 157 159 106 42 22 44 120 122 53 10 14 88 176 168 122 + 160 160 136 24 15 28 118 158 149 67 12 12 80 152 156 108 + 148 154 109 2 7 51 155 160 153 78 16 14 85 164 172 118 + 150 156 134 20 13 26 137 160 148 69 4 4 68 161 162 119 + 160 160 159 72 12 12 72 147 163 86 16 15 75 167 164 118 + 148 160 159 150 68 39 29 46 72 48 20 20 51 128 155 123 + 137 144 144 143 140 132 122 120 120 115 110 122 113 120 140 108 + 103 112 108 119 113 112 118 114 118 118 124 132 112 126 130 104 + 129 144 144 140 114 98 64 67 80 59 58 58 70 86 112 108 + 134 144 138 76 29 4 57 100 98 38 14 15 58 145 148 122 + 127 144 72 16 16 25 127 144 147 75 16 14 72 148 154 106 + 131 141 34 16 12 54 148 144 147 75 10 12 72 148 160 123 + 126 148 40 16 12 73 150 152 146 72 12 15 75 148 152 103 + 126 138 76 16 10 46 136 146 146 73 14 12 74 148 157 115 + 120 144 136 52 30 21 60 120 134 74 13 14 75 148 150 101 + 138 144 144 140 98 42 18 48 66 32 16 12 70 148 150 111 + 144 144 144 94 30 15 44 124 128 65 10 10 72 148 152 114 + 144 144 132 24 15 18 94 148 145 69 8 8 70 148 158 116 + 144 144 120 10 16 30 127 148 145 69 8 6 72 148 156 112 + 142 144 126 15 16 22 129 144 145 77 16 12 74 148 152 107 + 136 144 143 72 18 18 72 140 148 75 12 10 62 147 152 110 + 132 144 144 138 66 46 31 40 72 56 28 24 41 108 142 113 + 110 124 129 129 132 128 114 120 120 114 115 126 120 128 144 118 + 105 120 112 107 108 108 126 126 130 116 118 120 112 126 140 104 + 136 144 144 133 110 90 73 80 90 63 60 60 78 104 140 121 + 128 144 138 61 22 4 57 112 110 45 10 16 58 145 152 106 + 134 144 76 8 14 25 132 145 145 73 12 12 61 145 146 111 + 123 141 42 16 16 64 152 144 145 73 12 16 81 148 140 100 + 129 142 28 16 13 74 148 144 146 74 16 13 67 148 159 116 + 121 136 80 16 16 54 140 144 145 73 2 6 74 148 151 101 + 126 144 134 40 24 22 70 112 130 72 13 10 69 146 154 117 + 141 144 144 140 96 35 10 42 63 30 8 8 78 150 154 108 + 150 144 144 94 27 16 48 120 124 65 14 12 73 148 152 110 + 135 146 140 28 3 19 102 150 156 71 8 12 76 160 152 109 + 144 145 115 9 7 36 139 144 147 74 14 14 75 152 156 112 + 138 144 126 20 16 23 125 144 152 66 4 4 72 160 158 118 + 144 144 144 72 18 18 66 136 140 65 6 13 70 147 152 114 + 140 146 144 138 72 40 28 36 72 50 24 20 40 108 137 112 + 125 125 127 127 124 122 114 117 120 112 104 116 109 112 124 100 + + 116 127 106 123 107 128 116 132 120 122 108 118 119 118 123 108 + 132 138 156 164 160 166 155 172 160 168 156 172 162 164 155 140 + 120 102 150 161 172 164 154 159 157 176 152 164 161 167 128 120 + 112 86 64 77 90 80 80 75 76 88 80 85 68 75 51 113 + 120 74 20 14 16 13 16 4 12 14 12 14 4 15 20 122 + 118 70 16 8 12 4 18 13 16 10 12 16 4 16 20 110 + 120 65 41 60 77 60 88 88 41 53 67 78 69 86 48 115 + 126 89 106 150 153 152 161 148 76 122 149 153 148 163 72 120 + 116 80 116 160 160 160 160 136 54 120 158 160 160 147 46 120 + 115 78 61 146 164 168 168 84 18 44 118 155 137 72 29 122 + 105 112 4 34 62 91 80 33 40 22 28 51 26 12 39 132 + 109 126 32 16 11 15 24 30 102 42 15 7 13 12 68 140 + 116 142 77 16 10 16 16 40 152 106 24 2 20 72 150 143 + 112 156 144 76 36 28 76 136 160 159 136 109 134 159 159 144 + 116 157 151 144 155 150 146 152 160 157 160 154 156 160 160 144 + 108 148 136 141 143 141 144 124 157 152 160 148 150 160 148 137 + 104 108 122 106 123 103 115 101 111 114 116 112 107 110 113 118 + 130 112 148 154 160 152 157 150 150 152 158 156 152 152 142 144 + 126 86 145 148 148 148 148 148 148 148 148 148 148 147 108 128 + 112 70 58 72 72 75 74 75 70 72 70 72 74 62 41 120 + 132 58 15 14 12 15 12 14 12 10 8 6 12 10 24 126 + 124 58 14 16 10 12 14 13 16 10 8 8 16 12 28 115 + 118 59 38 75 75 72 73 74 32 65 69 69 77 75 56 114 + 118 80 98 147 147 146 146 134 66 128 145 145 145 148 72 120 + 114 67 100 144 144 152 146 120 48 124 148 148 144 140 40 120 + 118 64 57 127 148 150 136 60 18 44 94 127 129 72 31 114 + 112 98 4 25 54 73 46 21 42 15 18 30 22 18 46 128 + 113 114 29 16 12 12 10 30 98 30 15 16 16 18 66 132 + 119 140 76 16 16 16 16 52 140 94 24 10 15 72 138 129 + 108 144 138 72 34 40 76 136 144 144 132 120 126 143 144 129 + 112 144 144 144 141 148 138 144 144 144 144 144 144 144 144 124 + 103 129 134 127 131 126 126 120 138 144 144 144 142 136 132 110 + 104 121 106 111 100 116 101 117 108 110 109 112 118 114 112 100 + 140 140 152 146 140 159 151 154 154 152 152 156 158 152 137 124 + 126 104 145 145 148 148 148 146 150 148 160 152 160 147 108 112 + 112 78 58 61 81 67 74 69 78 73 76 75 72 70 40 109 + 120 60 16 12 16 13 6 10 8 12 12 14 4 13 20 116 + 118 60 10 12 12 16 2 13 8 14 8 14 4 6 24 104 + 116 63 45 73 73 74 73 72 30 65 71 74 66 65 50 112 + 130 90 110 145 145 146 145 130 63 124 156 147 152 140 72 120 + 126 80 112 145 144 144 144 112 42 120 150 144 144 136 36 117 + 126 73 57 132 152 148 140 70 10 48 102 139 125 66 28 114 + 108 90 4 25 64 74 54 22 35 16 19 36 23 18 40 122 + 108 110 22 14 16 13 16 24 96 27 3 7 16 18 72 124 + 107 133 61 8 16 16 16 40 140 94 28 9 20 72 138 127 + 112 144 138 76 42 28 80 134 144 144 140 115 126 144 144 127 + 120 144 144 144 141 142 136 144 144 144 146 145 144 144 146 125 + 105 136 128 134 123 129 121 126 141 150 135 144 138 144 140 125 + diff --git a/Utilidades/bin/python/Data/patt.c b/Utilidades/bin/python/Data/patt.c new file mode 100755 index 0000000..15a7303 --- /dev/null +++ b/Utilidades/bin/python/Data/patt.c @@ -0,0 +1,196 @@ + 123 134 136 128 134 116 105 93 104 109 120 129 134 120 110 106 + 142 156 168 168 145 97 59 54 80 85 84 84 119 70 140 154 + 158 172 163 130 33 14 56 125 168 164 128 95 21 9 145 160 + 161 166 122 32 22 52 144 166 164 164 163 162 95 20 162 172 + 144 142 52 19 28 125 167 160 162 176 176 164 153 60 145 146 + 177 106 13 17 44 143 170 169 172 171 171 160 160 103 143 151 + 136 52 19 26 81 168 176 176 176 174 176 173 170 161 160 152 + 144 24 20 24 92 178 173 172 175 175 168 168 168 164 172 165 + 147 27 18 12 60 160 166 172 174 166 160 160 161 164 157 154 + 154 51 20 27 76 177 163 162 172 165 167 174 163 168 166 171 + 156 60 4 14 42 157 174 176 176 176 176 172 172 172 169 157 + 155 124 6 3 8 112 160 170 170 164 170 173 175 162 174 168 + 148 152 65 9 9 59 167 172 164 173 168 160 144 82 149 141 + 154 174 164 75 29 20 97 140 160 166 157 130 66 108 158 156 + 160 164 169 170 116 65 49 50 72 86 68 82 135 158 156 138 + 138 145 150 161 148 130 127 112 111 112 116 136 151 160 160 158 + 118 127 120 112 120 120 110 100 104 109 118 120 124 110 106 106 + 147 160 160 164 152 106 71 56 65 82 84 90 135 98 160 157 + 138 160 160 144 38 8 51 120 154 156 122 95 24 24 150 168 + 141 161 132 28 14 52 132 160 160 160 160 160 97 26 150 152 + 159 149 52 16 16 113 159 160 160 160 160 160 158 60 138 158 + 148 91 11 15 46 149 162 160 160 160 160 160 171 133 157 154 + 140 48 13 13 56 156 164 160 160 160 160 160 160 160 156 152 + 140 20 14 16 76 160 160 160 160 160 160 160 160 160 152 138 + 143 16 16 9 65 160 160 160 160 160 160 160 160 160 160 165 + 146 43 12 11 54 167 160 160 160 160 160 160 160 160 158 163 + 158 70 14 12 41 151 160 160 160 160 160 160 160 160 159 158 + 150 137 19 16 28 129 160 160 160 160 160 160 166 150 162 160 + 142 160 72 16 16 75 169 161 160 160 160 166 156 90 159 163 + 135 160 151 65 22 16 86 139 162 168 155 133 58 108 160 146 + 156 164 160 154 100 58 37 46 68 76 62 70 128 158 160 150 + 148 153 148 157 146 131 119 103 102 108 116 136 148 155 160 154 + 97 126 127 115 120 120 101 95 108 116 116 118 126 112 106 120 + 141 164 166 164 145 106 68 55 72 81 84 84 124 70 136 144 + 156 160 160 138 42 18 49 109 152 156 128 89 32 25 163 172 + 152 158 132 32 10 42 130 160 160 162 163 166 102 36 161 164 + 151 151 56 16 14 110 159 160 160 168 160 160 158 52 128 142 + 163 119 20 15 42 140 160 160 160 162 164 169 160 104 153 143 + 159 76 24 9 53 154 160 160 160 161 162 160 162 161 160 162 + 148 32 15 6 63 158 162 160 160 160 160 160 164 170 166 151 + 138 19 8 13 73 173 166 160 160 160 160 160 160 169 159 152 + 144 39 20 25 68 164 160 160 160 160 160 160 160 160 158 168 + 156 56 12 17 51 159 164 160 160 160 160 160 160 160 169 168 + 132 130 19 16 19 127 164 162 160 160 160 159 159 142 154 144 + 144 160 73 16 13 66 164 165 160 160 160 158 136 68 147 162 + 151 162 152 69 23 22 96 148 160 160 155 130 66 108 160 158 + 138 161 168 170 104 58 47 54 73 74 65 70 128 158 156 134 + 138 159 164 164 146 133 129 116 106 108 120 136 151 160 155 141 + + 106 154 160 172 146 151 152 165 154 171 157 168 141 156 138 158 + 110 140 145 162 145 143 160 172 157 166 169 174 149 158 156 160 + 120 70 9 20 60 103 161 164 164 168 172 162 82 108 158 160 + 134 119 21 95 153 160 170 168 161 163 172 175 144 66 135 151 + 129 84 95 162 164 160 173 168 160 174 172 173 160 130 82 136 + 120 84 128 163 176 171 176 168 160 167 176 170 168 157 68 116 + 109 85 164 164 176 171 174 175 166 165 176 164 173 166 86 112 + 104 80 168 164 162 172 176 175 174 172 176 170 164 160 72 111 + 93 54 125 166 160 169 176 172 172 162 176 170 172 140 50 112 + 105 59 56 144 167 170 176 173 166 163 174 160 167 97 49 127 + 116 97 14 52 125 143 168 178 160 177 157 112 59 20 65 130 + 134 145 33 22 28 44 81 92 60 76 42 8 9 29 116 148 + 128 168 130 32 19 17 26 24 12 27 14 3 9 75 170 161 + 136 168 163 122 52 13 19 20 18 20 4 6 65 164 169 150 + 134 156 172 166 142 106 52 24 27 51 60 124 152 174 164 145 + 123 142 158 161 144 177 136 144 147 154 156 155 148 154 160 138 + 106 157 168 152 158 154 152 138 165 163 158 160 163 146 150 154 + 106 160 150 150 138 157 156 152 160 158 159 162 159 160 160 160 + 110 98 24 26 60 133 160 160 160 160 160 150 90 108 158 155 + 124 135 24 97 158 171 160 160 160 160 160 166 156 58 128 148 + 120 90 95 160 160 160 160 160 160 160 160 160 166 133 70 136 + 118 84 122 160 160 160 160 160 160 160 160 160 160 155 62 116 + 109 82 156 160 160 160 160 160 160 160 160 160 160 168 76 108 + 104 65 154 160 160 160 160 160 160 160 160 160 160 162 68 102 + 100 56 120 160 160 160 160 160 160 160 160 160 161 139 46 103 + 110 71 51 132 159 162 164 160 160 160 160 160 169 86 37 119 + 120 106 8 52 113 149 156 160 160 167 151 129 75 16 58 131 + 120 152 38 14 16 46 56 76 65 54 41 28 16 22 100 146 + 112 164 144 28 16 15 13 16 9 11 12 16 16 65 154 157 + 120 160 160 132 52 11 13 14 16 12 14 19 72 151 160 148 + 127 160 160 161 149 91 48 20 16 43 70 137 160 160 164 153 + 118 147 138 141 159 148 140 140 143 146 158 150 142 135 156 148 + 120 144 172 164 142 143 162 151 152 168 168 144 162 158 134 141 + 106 136 163 161 128 153 160 166 159 158 169 154 147 160 156 155 + 112 70 25 36 52 104 161 170 169 160 160 142 68 108 158 160 + 126 124 32 102 158 160 162 164 160 160 160 159 136 66 128 151 + 118 84 89 166 160 169 160 160 160 160 160 159 158 130 70 136 + 116 84 128 163 160 164 162 160 160 160 160 160 160 155 65 120 + 116 81 156 162 168 162 161 160 160 160 160 160 160 160 74 108 + 108 72 152 160 160 160 160 160 160 160 160 160 160 160 73 106 + 95 55 109 160 160 160 160 160 160 160 160 162 165 148 54 116 + 101 68 49 130 159 160 160 162 166 160 164 164 164 96 47 129 + 120 106 18 42 110 140 154 158 173 164 159 127 66 22 58 133 + 120 145 42 10 14 42 53 63 73 68 51 19 13 23 104 146 + 115 164 138 32 16 15 9 6 13 25 17 16 16 69 170 164 + 127 166 160 132 56 20 24 15 8 20 12 19 73 152 168 164 + 126 164 160 158 151 119 76 32 19 39 56 130 160 162 161 159 + 97 141 156 152 151 163 159 148 138 144 156 132 144 151 138 138 + + 158 160 160 151 136 116 112 111 112 127 130 148 161 150 145 138 + 138 156 158 135 82 68 86 72 50 49 65 116 170 169 164 160 + 156 158 108 66 130 157 166 160 140 97 20 29 75 164 174 154 + 141 149 82 144 160 168 173 164 172 167 59 9 9 65 152 148 + 168 174 162 175 173 170 164 170 170 160 112 8 3 6 124 155 + 157 169 172 172 172 176 176 176 176 174 157 42 14 4 60 156 + 171 166 168 163 174 167 165 172 162 163 177 76 27 20 51 154 + 154 157 164 161 160 160 166 174 172 166 160 60 12 18 27 147 + 165 172 164 168 168 168 175 175 172 173 178 92 24 20 24 144 + 152 160 161 170 173 176 174 176 176 176 168 81 26 19 52 136 + 151 143 103 160 160 171 171 172 169 170 143 44 17 13 106 177 + 146 145 60 153 164 176 176 162 160 167 125 28 19 52 142 144 + 172 162 20 95 162 163 164 164 166 144 52 22 32 122 166 161 + 160 145 9 21 95 128 164 168 125 56 14 33 130 163 172 158 + 154 140 70 119 84 84 85 80 54 59 97 145 168 168 156 142 + 106 110 120 134 129 120 109 104 93 105 116 134 128 136 134 123 + 154 160 155 148 136 116 108 102 103 119 131 146 157 148 153 148 + 150 160 158 128 70 62 76 68 46 37 58 100 154 160 164 156 + 146 160 108 58 133 155 168 162 139 86 16 22 65 151 160 135 + 163 159 90 156 166 160 160 160 161 169 75 16 16 72 160 142 + 160 162 150 166 160 160 160 160 160 160 129 28 16 19 137 150 + 158 159 160 160 160 160 160 160 160 160 151 41 12 14 70 158 + 163 158 160 160 160 160 160 160 160 160 167 54 11 12 43 146 + 165 160 160 160 160 160 160 160 160 160 160 65 9 16 16 143 + 138 152 160 160 160 160 160 160 160 160 160 76 16 14 20 140 + 152 156 160 160 160 160 160 160 160 164 156 56 13 13 48 140 + 154 157 133 171 160 160 160 160 160 162 149 46 15 11 91 148 + 158 138 60 158 160 160 160 160 160 159 113 16 16 52 149 159 + 152 150 26 97 160 160 160 160 160 132 52 14 28 132 161 141 + 168 150 24 24 95 122 156 154 120 51 8 38 144 160 160 138 + 157 160 98 135 90 84 82 65 56 71 106 152 164 160 160 147 + 106 106 110 124 120 118 109 104 100 110 120 120 112 120 127 118 + 141 155 160 151 136 120 108 106 116 129 133 146 164 164 159 138 + 134 156 158 128 70 65 74 73 54 47 58 104 170 168 161 138 + 158 160 108 66 130 155 160 160 148 96 22 23 69 152 162 151 + 162 147 68 136 158 160 160 160 165 164 66 13 16 73 160 144 + 144 154 142 159 159 160 160 160 162 164 127 19 16 19 130 132 + 168 169 160 160 160 160 160 160 160 164 159 51 17 12 56 156 + 168 158 160 160 160 160 160 160 160 160 164 68 25 20 39 144 + 152 159 169 160 160 160 160 160 160 166 173 73 13 8 19 138 + 151 166 170 164 160 160 160 160 160 162 158 63 6 15 32 148 + 162 160 161 162 160 162 161 160 160 160 154 53 9 24 76 159 + 143 153 104 160 169 164 162 160 160 160 140 42 15 20 119 163 + 142 128 52 158 160 160 168 160 160 159 110 14 16 56 151 151 + 164 161 36 102 166 163 162 160 160 130 42 10 32 132 158 152 + 172 163 25 32 89 128 156 152 109 49 18 42 138 160 160 156 + 144 136 70 124 84 84 81 72 55 68 106 145 164 166 164 141 + 120 106 112 126 118 116 116 108 95 101 120 120 115 127 126 97 + + 138 160 154 148 155 156 154 147 144 136 177 144 161 158 142 123 + 145 164 174 152 124 60 51 27 24 52 106 142 166 172 156 134 + 150 169 164 65 6 4 20 18 20 19 13 52 122 163 168 136 + 161 170 75 9 3 14 27 12 24 26 17 19 32 130 168 128 + 148 116 29 9 8 42 76 60 92 81 44 28 22 33 145 134 + 130 65 20 59 112 157 177 160 178 168 143 125 52 14 97 116 + 127 49 97 167 160 174 163 166 173 176 170 167 144 56 59 105 + 112 50 140 172 170 176 162 172 172 176 169 160 166 125 54 93 + 111 72 160 164 170 176 172 174 175 176 172 162 164 168 80 104 + 112 86 166 173 164 176 165 166 175 174 171 176 164 164 85 109 + 116 68 157 168 170 176 167 160 168 176 171 176 163 128 84 120 + 136 82 130 160 173 172 174 160 168 173 160 164 162 95 84 129 + 151 135 66 144 175 172 163 161 168 170 160 153 95 21 119 134 + 160 158 108 82 162 172 168 164 164 161 103 60 20 9 70 120 + 160 156 158 149 174 169 166 157 172 160 143 145 162 145 140 110 + 158 138 156 141 168 157 171 154 165 152 151 146 172 160 154 106 + 148 156 135 142 150 158 146 143 140 140 148 159 141 138 147 118 + 153 164 160 160 137 70 43 16 20 48 91 149 161 160 160 127 + 148 160 151 72 19 14 12 16 14 13 11 52 132 160 160 120 + 157 154 65 16 16 12 11 9 16 13 15 16 28 144 164 112 + 146 100 22 16 28 41 54 65 76 56 46 16 14 38 152 120 + 131 58 16 75 129 151 167 160 160 156 149 113 52 8 106 120 + 119 37 86 169 160 160 160 160 160 164 162 159 132 51 71 110 + 103 46 139 161 160 160 160 160 160 160 160 160 160 120 56 100 + 102 68 162 160 160 160 160 160 160 160 160 160 160 154 65 104 + 108 76 168 160 160 160 160 160 160 160 160 160 160 156 82 109 + 116 62 155 160 160 160 160 160 160 160 160 160 160 122 84 118 + 136 70 133 166 160 160 160 160 160 160 160 160 160 95 90 120 + 148 128 58 156 166 160 160 160 160 160 171 158 97 24 135 124 + 155 158 108 90 150 160 160 160 160 160 133 60 26 24 98 110 + 160 160 160 159 162 159 158 160 152 156 157 138 150 150 160 106 + 154 150 146 163 160 158 163 165 138 152 154 158 152 168 157 106 + 138 138 151 144 132 156 144 138 148 159 163 151 152 156 141 97 + 159 161 162 160 130 56 39 19 32 76 119 151 158 160 164 126 + 164 168 152 73 19 12 20 8 15 24 20 56 132 160 166 127 + 164 170 69 16 16 17 25 13 6 9 15 16 32 138 164 115 + 146 104 23 13 19 51 68 73 63 53 42 14 10 42 145 120 + 133 58 22 66 127 159 164 173 158 154 140 110 42 18 106 120 + 129 47 96 164 164 164 160 166 162 160 160 159 130 49 68 101 + 116 54 148 165 162 160 160 160 160 160 160 160 160 109 55 95 + 106 73 160 160 160 160 160 160 160 160 160 160 160 152 72 108 + 108 74 160 160 160 160 160 160 160 161 162 168 162 156 81 116 + 120 65 155 160 160 160 160 160 160 162 164 160 163 128 84 116 + 136 70 130 158 159 160 160 160 160 160 169 160 166 89 84 118 + 151 128 66 136 159 160 160 160 164 162 160 158 102 32 124 126 + 160 158 108 68 142 160 160 169 170 161 104 52 36 25 70 112 + 155 156 160 147 154 169 158 159 166 160 153 128 161 163 136 106 + 141 134 158 162 144 168 168 152 151 162 143 142 164 172 144 120 + diff --git a/Utilidades/bin/python/Data/patt.d b/Utilidades/bin/python/Data/patt.d new file mode 100755 index 0000000..52c6e4f --- /dev/null +++ b/Utilidades/bin/python/Data/patt.d @@ -0,0 +1,196 @@ + 138 158 163 155 161 160 157 150 148 136 142 138 140 134 121 122 + 122 122 124 130 118 132 136 125 147 164 166 170 176 176 176 159 + 153 160 95 26 22 27 86 89 50 40 82 134 176 176 174 166 + 143 170 157 20 16 29 170 175 164 98 22 34 96 164 168 174 + 140 174 134 13 17 34 138 174 176 155 44 10 18 124 182 167 + 143 176 155 36 16 21 133 175 176 169 110 22 24 65 164 177 + 133 171 160 22 16 19 136 174 176 172 138 18 18 9 112 162 + 144 179 146 16 16 16 142 176 176 174 162 16 16 12 76 164 + 137 173 143 14 13 11 143 175 176 176 161 38 16 21 70 159 + 144 173 134 15 16 23 140 174 176 176 173 29 16 17 74 159 + 157 172 149 15 16 16 147 173 176 176 158 27 16 16 104 179 + 146 173 146 14 19 27 156 176 176 170 137 22 18 35 139 163 + 146 165 143 33 21 22 146 169 174 176 85 16 18 70 170 161 + 148 168 148 25 17 29 148 169 160 139 31 20 58 148 176 166 + 128 150 101 22 10 9 91 133 104 57 44 92 161 167 169 167 + 125 114 109 107 105 86 91 92 95 114 142 160 164 152 164 154 + 126 147 147 145 150 144 146 136 128 118 126 121 121 112 99 112 + 122 116 110 122 118 124 137 126 146 154 156 160 160 160 160 157 + 124 136 82 24 22 26 86 83 50 26 81 120 160 160 160 159 + 119 160 145 24 14 11 139 159 148 82 9 19 88 166 160 156 + 125 160 144 17 13 12 126 160 160 152 52 13 21 110 160 156 + 113 160 139 22 16 17 121 160 160 160 97 12 15 35 146 160 + 132 160 140 15 5 8 122 160 160 160 145 16 16 9 126 172 + 136 160 139 8 10 12 132 160 160 160 162 26 16 16 76 158 + 125 160 136 19 8 15 129 160 160 160 150 24 16 12 56 161 + 139 161 148 25 16 15 133 160 160 160 156 20 16 16 65 154 + 131 166 149 19 9 12 133 160 160 160 148 25 16 15 86 157 + 130 160 150 22 11 22 143 160 160 160 134 16 16 18 119 156 + 124 160 137 25 11 22 132 160 160 164 79 12 9 54 153 151 + 129 160 132 17 12 18 146 162 160 138 26 5 34 130 160 146 + 133 145 101 14 7 8 92 131 101 46 23 74 145 158 160 155 + 113 104 101 97 99 79 76 83 83 102 123 150 156 156 158 146 + 105 152 146 140 152 147 141 134 133 120 120 123 128 124 108 122 + 113 117 109 118 117 119 130 122 138 158 158 161 162 160 167 173 + 138 144 85 18 12 20 75 83 49 32 81 122 162 162 166 169 + 133 166 137 11 4 14 144 165 146 84 15 32 92 161 162 169 + 140 163 136 11 11 28 133 160 160 152 40 14 6 100 166 158 + 138 167 141 29 16 24 134 160 160 162 103 12 10 51 144 152 + 142 173 156 27 16 19 135 160 160 168 145 11 18 9 104 158 + 124 163 151 21 16 17 140 160 160 160 162 19 16 12 80 152 + 117 160 139 24 9 5 135 164 165 172 159 22 10 7 58 152 + 127 158 136 15 7 6 130 162 160 164 165 28 16 6 57 145 + 133 160 135 9 11 2 127 160 160 162 155 28 16 4 85 148 + 140 164 134 11 10 5 134 160 162 160 130 22 16 18 121 161 + 137 162 128 16 14 14 132 166 164 168 88 16 11 54 161 165 + 142 168 143 23 16 19 138 156 164 148 34 16 43 133 164 170 + 139 158 111 21 10 13 86 132 109 54 30 76 145 164 164 180 + 107 104 105 98 100 79 81 80 80 95 123 158 156 156 156 158 + + 122 159 166 174 167 177 162 164 159 159 179 163 161 166 167 154 + 121 176 174 168 182 164 112 76 70 74 104 139 170 176 169 164 + 134 176 176 164 124 65 9 12 21 17 16 35 70 148 167 152 + 140 176 176 96 18 24 18 16 16 16 16 18 18 58 161 164 + 138 170 134 34 10 22 18 16 38 29 27 22 16 20 92 160 + 142 166 82 22 44 110 138 162 161 173 158 137 85 31 44 142 + 136 164 40 98 155 169 172 174 176 176 176 170 176 139 57 114 + 148 147 50 164 176 176 176 176 176 176 176 176 174 160 104 95 + 150 125 89 175 174 175 174 176 175 174 173 176 169 169 133 92 + 157 136 86 170 138 133 136 142 143 140 147 156 146 148 91 91 + 160 132 27 29 34 21 19 16 11 23 16 27 22 29 9 86 + 161 118 22 16 17 16 16 16 13 16 16 19 21 17 10 105 + 155 130 26 20 13 36 22 16 14 15 15 14 33 25 22 107 + 163 124 95 157 134 155 160 146 143 134 149 146 143 148 101 109 + 158 122 160 170 174 176 171 179 173 173 172 173 165 168 150 114 + 138 122 153 143 140 143 133 144 137 144 157 146 146 148 128 125 + 112 157 159 156 156 160 172 158 161 154 157 156 151 146 155 146 + 99 160 160 160 160 146 126 76 56 65 86 119 153 160 160 158 + 112 160 160 166 110 35 9 16 12 16 15 18 54 130 158 156 + 121 160 160 88 21 15 16 16 16 16 16 16 9 34 145 156 + 121 160 120 19 13 12 16 26 24 20 25 16 12 5 74 150 + 126 156 81 9 52 97 145 162 150 156 148 134 79 26 23 123 + 118 154 26 82 152 160 160 160 160 160 160 160 164 138 46 102 + 128 146 50 148 160 160 160 160 160 160 160 160 160 160 101 83 + 136 126 83 159 160 160 160 160 160 160 160 160 160 162 131 83 + 146 137 86 139 126 121 122 132 129 133 133 143 132 146 92 76 + 144 124 26 11 12 17 8 12 15 15 12 22 22 18 8 79 + 150 118 22 14 13 16 5 10 8 16 9 11 11 12 7 99 + 145 122 24 24 17 22 15 8 19 25 19 22 25 17 14 97 + 147 110 82 145 144 139 140 139 136 148 149 150 137 132 101 101 + 147 116 136 160 160 160 160 160 160 161 166 160 160 160 145 104 + 126 122 124 119 125 113 132 136 125 139 131 130 124 129 133 113 + 122 173 169 169 158 152 158 152 152 145 148 161 165 170 180 158 + 108 167 166 162 166 144 104 80 58 57 85 121 161 164 164 156 + 124 160 162 161 100 51 9 12 7 6 4 18 54 133 164 156 + 128 162 162 92 6 10 18 16 10 16 16 16 11 43 145 156 + 123 161 122 32 14 12 11 19 22 28 28 22 16 16 76 158 + 120 158 81 15 40 103 145 162 159 165 155 130 88 34 30 123 + 120 158 32 84 152 162 168 160 172 164 162 160 168 148 54 95 + 133 138 49 146 160 160 160 160 165 160 160 162 164 164 109 80 + 134 122 83 165 160 160 160 160 164 162 160 160 166 156 132 80 + 141 130 75 144 133 134 135 140 135 130 127 134 132 138 86 81 + 147 119 20 14 28 24 19 17 5 6 2 5 14 19 13 79 + 152 117 12 4 11 16 16 16 9 7 11 10 14 16 10 100 + 140 118 18 11 11 29 27 21 24 15 9 11 16 23 21 98 + 146 109 85 137 136 141 156 151 139 136 135 134 128 143 111 105 + 152 117 144 166 163 167 173 163 160 158 160 164 162 168 158 104 + 105 113 138 133 140 138 142 124 117 127 133 140 137 142 139 107 + + 154 164 152 164 160 142 114 95 92 91 86 105 107 109 114 125 + 167 169 167 161 92 44 57 104 133 91 9 10 22 101 150 128 + 166 176 148 58 20 31 139 160 169 148 29 17 25 148 168 148 + 161 170 70 18 16 85 176 174 169 146 22 21 33 143 165 146 + 163 139 35 18 22 137 170 176 176 156 27 19 14 146 173 146 + 179 104 16 16 27 158 176 176 173 147 16 16 15 149 172 157 + 159 74 17 16 29 173 176 176 174 140 23 16 15 134 173 144 + 159 70 21 16 38 161 176 176 175 143 11 13 14 143 173 137 + 164 76 12 16 16 162 174 176 176 142 16 16 16 146 179 144 + 162 112 9 18 18 138 172 176 174 136 19 16 22 160 171 133 + 177 164 65 24 22 110 169 176 175 133 21 16 36 155 176 143 + 167 182 124 18 10 44 155 176 174 138 34 17 13 134 174 140 + 174 168 164 96 34 22 98 164 175 170 29 16 20 157 170 143 + 166 174 176 176 134 82 40 50 89 86 27 22 26 95 160 153 + 159 176 176 176 170 166 164 147 125 136 132 118 130 124 122 122 + 122 121 134 140 138 142 136 148 150 157 160 161 155 163 158 138 + 146 158 156 156 150 123 102 83 83 76 79 99 97 101 104 113 + 155 160 158 145 74 23 46 101 131 92 8 7 14 101 145 133 + 146 160 130 34 5 26 138 160 162 146 18 12 17 132 160 129 + 151 153 54 9 12 79 164 160 160 132 22 11 25 137 160 124 + 156 119 18 16 16 134 160 160 160 143 22 11 22 150 160 130 + 157 86 15 16 25 148 160 160 160 133 12 9 19 149 166 131 + 154 65 16 16 20 156 160 160 160 133 15 16 25 148 161 139 + 161 56 12 16 24 150 160 160 160 129 15 8 19 136 160 125 + 158 76 16 16 26 162 160 160 160 132 12 10 8 139 160 136 + 172 126 9 16 16 145 160 160 160 122 8 5 15 140 160 132 + 160 146 35 15 12 97 160 160 160 121 17 16 22 139 160 113 + 156 160 110 21 13 52 152 160 160 126 12 13 17 144 160 125 + 156 160 166 88 19 9 82 148 159 139 11 14 24 145 160 119 + 159 160 160 160 120 81 26 50 83 86 26 22 24 82 136 124 + 157 160 160 160 160 156 154 146 126 137 124 118 122 110 116 122 + 112 99 112 121 121 126 118 128 136 146 144 150 145 147 147 126 + 158 156 156 156 158 123 95 80 80 81 79 100 98 105 104 107 + 180 164 164 145 76 30 54 109 132 86 13 10 21 111 158 139 + 170 164 133 43 16 34 148 164 156 138 19 16 23 143 168 142 + 165 161 54 11 16 88 168 164 166 132 14 14 16 128 162 137 + 161 121 18 16 22 130 160 162 160 134 5 10 11 134 164 140 + 148 85 4 16 28 155 162 160 160 127 2 11 9 135 160 133 + 145 57 6 16 28 165 164 160 162 130 6 7 15 136 158 127 + 152 58 7 10 22 159 172 165 164 135 5 9 24 139 160 117 + 152 80 12 16 19 162 160 160 160 140 17 16 21 151 163 124 + 158 104 9 18 11 145 168 160 160 135 19 16 27 156 173 142 + 152 144 51 10 12 103 162 160 160 134 24 16 29 141 167 138 + 158 166 100 6 14 40 152 160 160 133 28 11 11 136 163 140 + 169 162 161 92 32 15 84 146 165 144 14 4 11 137 166 133 + 169 166 162 162 122 81 32 49 83 75 20 12 18 85 144 138 + 173 167 160 162 161 158 158 138 122 130 119 117 118 109 117 113 + 122 108 124 128 123 120 120 133 134 141 147 152 140 146 152 105 + + 125 128 148 146 146 157 144 137 144 133 143 140 143 153 122 138 + 114 150 168 165 173 172 173 173 179 171 176 174 170 160 122 158 + 109 101 148 143 146 149 134 143 146 160 155 134 157 95 124 163 + 107 22 25 33 14 15 15 14 16 22 36 13 20 26 130 155 + 105 10 17 21 19 16 16 13 16 16 16 17 16 22 118 161 + 86 9 29 22 27 16 23 11 16 19 21 34 29 27 132 160 + 91 91 148 146 156 147 140 143 142 136 133 138 170 86 136 157 + 92 133 169 169 176 173 174 175 176 174 175 174 175 89 125 150 + 95 104 160 174 176 176 176 176 176 176 176 176 164 50 147 148 + 114 57 139 176 170 176 176 176 174 172 169 155 98 40 164 136 + 142 44 31 85 137 158 173 161 162 138 110 44 22 82 166 142 + 160 92 20 16 22 27 29 38 16 18 22 10 34 134 170 138 + 164 161 58 18 18 16 16 16 16 18 24 18 96 176 176 140 + 152 167 148 70 35 16 17 21 12 9 65 124 164 176 176 134 + 164 169 176 170 139 104 74 70 76 112 164 182 168 174 176 121 + 154 167 166 161 163 179 159 159 164 162 177 167 174 166 159 122 + 113 133 129 124 130 131 139 125 136 132 113 125 119 124 122 126 + 104 145 160 160 160 166 161 160 160 160 160 160 160 136 116 147 + 101 101 132 137 150 149 148 136 139 140 139 144 145 82 110 147 + 97 14 17 25 22 19 25 19 8 15 22 17 24 24 122 145 + 99 7 12 11 11 9 16 8 10 5 16 13 14 22 118 150 + 79 8 18 22 22 12 15 15 12 8 17 12 11 26 124 144 + 76 92 146 132 143 133 133 129 132 122 121 126 139 86 137 146 + 83 131 162 160 160 160 160 160 160 160 160 160 159 83 126 136 + 83 101 160 160 160 160 160 160 160 160 160 160 148 50 146 128 + 102 46 138 164 160 160 160 160 160 160 160 152 82 26 154 118 + 123 23 26 79 134 148 156 150 162 145 97 52 9 81 156 126 + 150 74 5 12 16 25 20 24 26 16 12 13 19 120 160 121 + 156 145 34 9 16 16 16 16 16 16 15 21 88 160 160 121 + 156 158 130 54 18 15 16 12 16 9 35 110 166 160 160 112 + 158 160 160 153 119 86 65 56 76 126 146 160 160 160 160 99 + 146 155 146 151 156 157 154 161 158 172 160 156 156 159 157 112 + 107 139 142 137 140 133 127 117 124 142 138 140 133 138 113 105 + 104 158 168 162 164 160 158 160 163 173 167 163 166 144 117 152 + 105 111 143 128 134 135 136 139 151 156 141 136 137 85 109 146 + 98 21 23 16 11 9 15 24 21 27 29 11 11 18 118 140 + 100 10 16 14 10 11 7 9 16 16 16 11 4 12 117 152 + 79 13 19 14 5 2 6 5 17 19 24 28 14 20 119 147 + 81 86 138 132 134 127 130 135 140 135 134 133 144 75 130 141 + 80 132 156 166 160 160 162 164 160 160 160 160 165 83 122 134 + 80 109 164 164 162 160 160 165 160 160 160 160 146 49 138 133 + 95 54 148 168 160 162 164 172 160 168 162 152 84 32 158 120 + 123 30 34 88 130 155 165 159 162 145 103 40 15 81 158 120 + 158 76 16 16 22 28 28 22 19 11 12 14 32 122 161 123 + 156 145 43 11 16 16 16 10 16 18 10 6 92 162 162 128 + 156 164 133 54 18 4 6 7 12 9 51 100 161 162 160 124 + 156 164 164 161 121 85 57 58 80 104 144 166 162 166 167 108 + 158 180 170 165 161 148 145 152 152 158 152 158 169 169 173 122 + diff --git a/Utilidades/bin/python/Data/patt.f b/Utilidades/bin/python/Data/patt.f new file mode 100755 index 0000000..94fe9ca --- /dev/null +++ b/Utilidades/bin/python/Data/patt.f @@ -0,0 +1,196 @@ + 146 151 146 148 144 150 150 136 131 141 144 144 142 142 143 140 + 163 170 150 114 74 56 68 96 113 108 98 94 77 105 167 168 + 148 172 162 160 38 17 26 112 154 160 148 118 60 77 168 156 + 152 175 170 160 58 16 21 94 170 176 176 176 148 88 172 155 + 155 170 176 163 63 16 11 116 172 176 167 166 172 123 170 152 + 148 176 176 160 53 16 24 134 172 166 128 154 176 156 172 151 + 164 176 175 167 62 16 16 110 165 145 77 142 176 173 172 148 + 155 176 175 173 50 16 30 92 126 90 28 153 176 176 173 151 + 146 171 172 164 36 16 29 101 118 83 44 158 174 176 168 166 + 157 175 176 164 52 16 24 111 164 148 70 140 173 174 168 164 + 153 176 176 167 56 19 24 124 176 166 129 152 175 176 176 160 + 156 176 176 156 43 16 22 130 176 176 158 160 167 171 168 147 + 159 173 176 166 47 16 19 125 173 176 176 176 176 168 168 156 + 156 176 174 159 40 19 22 102 164 176 176 176 176 168 166 148 + 158 180 164 126 81 69 62 90 132 164 176 176 176 174 171 143 + 135 152 152 152 149 150 137 134 140 162 160 160 160 158 158 138 + 132 147 138 136 136 129 130 120 124 139 144 144 144 138 130 136 + 149 158 141 110 66 48 58 80 97 84 82 80 68 96 156 152 + 137 164 160 154 30 16 21 103 150 144 136 112 52 65 160 150 + 140 160 160 152 48 16 22 96 160 160 160 160 136 72 160 151 + 143 160 160 154 53 16 7 108 160 160 160 160 166 108 160 155 + 148 160 160 157 50 16 14 120 160 160 114 139 164 154 160 144 + 152 160 160 147 47 16 16 102 159 142 75 138 160 160 160 140 + 143 160 160 160 48 16 16 76 114 84 26 144 166 160 160 150 + 142 160 164 160 42 16 19 85 104 70 32 150 164 160 160 158 + 140 160 160 152 52 16 22 107 162 146 60 130 164 160 160 152 + 140 160 160 156 53 16 11 108 164 166 126 142 160 160 160 152 + 152 165 160 153 42 16 16 120 164 164 150 152 160 160 160 147 + 150 163 163 152 47 16 16 111 161 161 160 160 160 160 160 154 + 140 160 160 156 38 16 16 96 164 164 160 160 160 161 162 142 + 146 160 142 108 64 58 53 81 132 152 160 160 160 161 161 139 + 131 146 136 144 139 150 137 132 136 150 148 152 154 160 160 142 + 134 151 146 142 136 151 156 135 127 143 144 132 133 134 135 142 + 158 166 144 110 62 48 50 76 89 82 76 73 57 92 158 156 + 142 164 160 148 32 16 20 109 150 148 142 116 41 61 158 146 + 140 170 166 160 54 16 15 94 160 160 160 160 132 68 160 151 + 143 168 172 164 54 16 16 116 160 160 157 157 162 109 160 146 + 144 160 160 149 48 16 14 120 163 173 119 135 164 156 160 144 + 152 172 169 154 59 16 12 106 158 142 70 138 160 160 160 142 + 144 162 162 160 48 16 16 76 110 74 20 144 160 160 166 148 + 136 162 165 160 34 15 14 79 104 67 24 146 160 160 162 162 + 149 171 166 164 52 12 10 114 170 144 61 131 162 174 172 160 + 144 172 162 158 54 16 12 104 160 163 117 143 162 162 160 148 + 148 168 166 157 50 16 10 120 160 160 148 158 163 166 160 148 + 158 160 160 156 47 16 16 119 162 166 160 160 164 160 160 151 + 140 160 158 152 26 9 14 96 164 160 160 160 165 160 164 146 + 150 168 143 104 62 50 50 75 121 148 160 170 161 164 165 139 + 136 152 160 160 153 155 138 134 142 158 156 160 160 161 163 140 + + 140 168 156 155 152 151 148 151 166 164 160 147 156 148 143 138 + 143 167 168 172 170 172 172 173 168 168 176 168 168 166 171 158 + 142 105 77 88 123 156 173 176 176 174 176 171 168 168 174 158 + 142 77 60 148 172 176 176 176 174 173 175 167 176 176 176 160 + 144 94 118 176 166 154 142 153 158 140 152 160 176 176 176 160 + 144 98 148 176 167 128 77 28 44 70 129 158 176 176 176 160 + 141 108 160 176 176 166 145 90 83 148 166 176 176 176 164 162 + 131 113 154 170 172 172 165 126 118 164 176 176 173 164 132 140 + 136 96 112 94 116 134 110 92 101 111 124 130 125 102 90 134 + 150 68 26 21 11 24 16 30 29 24 24 22 19 22 62 137 + 150 56 17 16 16 16 16 16 16 16 19 16 16 19 69 150 + 144 74 38 58 63 53 62 50 36 52 56 43 47 40 81 149 + 148 114 160 160 163 160 167 173 164 164 167 156 166 159 126 152 + 146 150 162 170 176 176 175 175 172 176 176 176 176 174 164 152 + 151 170 172 175 170 176 176 176 171 175 176 176 173 176 180 152 + 146 163 148 152 155 148 164 155 146 157 153 156 159 156 158 135 + 136 152 150 151 155 144 140 150 158 152 152 147 154 142 139 142 + 130 156 160 160 160 160 160 160 160 160 160 160 160 162 161 160 + 138 96 65 72 108 154 160 160 160 160 160 160 160 161 161 160 + 144 68 52 136 166 164 160 166 164 164 160 160 160 160 160 154 + 144 80 112 160 160 139 138 144 150 130 142 152 160 160 160 152 + 144 82 136 160 160 114 75 26 32 60 126 150 160 160 160 148 + 139 84 144 160 160 160 142 84 70 146 166 164 161 164 152 150 + 124 97 150 160 160 160 159 114 104 162 164 164 161 164 132 136 + 120 80 103 96 108 120 102 76 85 107 108 120 111 96 81 132 + 130 58 21 22 7 14 16 16 19 22 11 16 16 16 53 137 + 129 48 16 16 16 16 16 16 16 16 16 16 16 16 58 150 + 136 66 30 48 53 50 47 48 42 52 53 42 47 38 64 139 + 136 110 154 152 154 157 147 160 160 152 156 153 152 156 108 144 + 138 141 160 160 160 160 160 160 164 160 160 160 163 160 142 136 + 147 158 164 160 160 160 160 160 160 160 160 165 163 160 160 146 + 132 149 137 140 143 148 152 143 142 140 140 152 150 140 146 131 + 142 156 146 151 146 144 142 148 162 160 148 148 151 146 139 140 + 135 158 158 160 160 160 160 166 162 172 160 160 160 164 165 163 + 134 92 61 68 109 156 160 160 160 174 162 166 160 160 164 161 + 133 57 41 132 162 164 160 160 160 162 162 163 164 165 161 160 + 132 73 116 160 157 135 138 144 146 131 143 158 160 160 170 160 + 144 76 142 160 157 119 70 20 24 61 117 148 160 160 160 156 + 143 82 148 160 160 173 142 74 67 144 163 160 166 160 148 158 + 127 89 150 160 160 163 158 110 104 170 160 160 162 164 121 142 + 135 76 109 94 116 120 106 76 79 114 104 120 119 96 75 134 + 156 50 20 15 16 14 12 16 14 10 12 10 16 14 50 138 + 151 48 16 16 16 16 16 16 15 12 16 16 16 9 50 155 + 136 62 32 54 54 48 59 48 34 52 54 50 47 26 62 153 + 142 110 148 160 164 149 154 160 160 164 158 157 156 152 104 160 + 146 144 160 166 172 160 169 162 165 166 162 166 160 158 143 160 + 151 166 164 170 168 160 172 162 162 171 172 168 160 160 168 152 + 134 158 142 140 143 144 152 144 136 149 144 148 158 140 150 136 + + 138 158 158 160 160 160 162 140 134 137 150 149 152 152 152 135 + 143 171 174 176 176 176 164 132 90 62 69 81 126 164 180 158 + 148 166 168 176 176 176 176 164 102 22 19 40 159 174 176 156 + 156 168 168 176 176 176 176 173 125 19 16 47 166 176 173 159 + 147 168 171 167 160 158 176 176 130 22 16 43 156 176 176 156 + 160 176 176 175 152 129 166 176 124 24 19 56 167 176 176 153 + 164 168 174 173 140 70 148 164 111 24 16 52 164 176 175 157 + 166 168 176 174 158 44 83 118 101 29 16 36 164 172 171 146 + 151 173 176 176 153 28 90 126 92 30 16 50 173 175 176 155 + 148 172 173 176 142 77 145 165 110 16 16 62 167 175 176 164 + 151 172 156 176 154 128 166 172 134 24 16 53 160 176 176 148 + 152 170 123 172 166 167 176 172 116 11 16 63 163 176 170 155 + 155 172 88 148 176 176 176 170 94 21 16 58 160 170 175 152 + 156 168 77 60 118 148 160 154 112 26 17 38 160 162 172 148 + 168 167 105 77 94 98 108 113 96 68 56 74 114 150 170 163 + 140 143 142 142 144 144 141 131 136 150 150 144 148 146 151 146 + 142 160 160 154 152 148 150 136 132 137 150 139 144 136 146 131 + 139 161 161 160 160 160 152 132 81 53 58 64 108 142 160 146 + 142 162 161 160 160 160 164 164 96 16 16 38 156 160 160 140 + 154 160 160 160 160 160 161 161 111 16 16 47 152 163 163 150 + 147 160 160 160 152 150 164 164 120 16 16 42 153 160 165 152 + 152 160 160 160 142 126 166 164 108 11 16 53 156 160 160 140 + 152 160 160 164 130 60 146 162 107 22 16 52 152 160 160 140 + 158 160 160 164 150 32 70 104 85 19 16 42 160 164 160 142 + 150 160 160 166 144 26 84 114 76 16 16 48 160 160 160 143 + 140 160 160 160 138 75 142 159 102 16 16 47 147 160 160 152 + 144 160 154 164 139 114 160 160 120 14 16 50 157 160 160 148 + 155 160 108 166 160 160 160 160 108 7 16 53 154 160 160 143 + 151 160 72 136 160 160 160 160 96 22 16 48 152 160 160 140 + 150 160 65 52 112 136 144 150 103 21 16 30 154 160 164 137 + 152 156 96 68 80 82 84 97 80 58 48 66 110 141 158 149 + 136 130 138 144 144 144 139 124 120 130 129 136 136 138 147 132 + 140 163 161 160 160 156 158 142 134 138 155 153 160 160 152 136 + 139 165 164 161 170 160 148 121 75 50 50 62 104 143 168 150 + 146 164 160 165 160 160 160 164 96 14 9 26 152 158 160 140 + 151 160 160 164 160 160 166 162 119 16 16 47 156 160 160 158 + 148 160 166 163 158 148 160 160 120 10 16 50 157 166 168 148 + 148 160 162 162 143 117 163 160 104 12 16 54 158 162 172 144 + 160 172 174 162 131 61 144 170 114 10 12 52 164 166 171 149 + 162 162 160 160 146 24 67 104 79 14 15 34 160 165 162 136 + 148 166 160 160 144 20 74 110 76 16 16 48 160 162 162 144 + 142 160 160 160 138 70 142 158 106 12 16 59 154 169 172 152 + 144 160 156 164 135 119 173 163 120 14 16 48 149 160 160 144 + 146 160 109 162 157 157 160 160 116 16 16 54 164 172 168 143 + 151 160 68 132 160 160 160 160 94 15 16 54 160 166 170 140 + 146 158 61 41 116 142 148 150 109 20 16 32 148 160 164 142 + 156 158 92 57 73 76 82 89 76 50 48 62 110 144 166 158 + 142 135 134 133 132 144 143 127 135 156 151 136 142 146 151 134 + + 135 158 156 159 156 153 157 146 155 164 148 155 152 148 163 146 + 152 180 176 173 176 176 175 171 176 176 176 170 175 172 170 151 + 152 164 174 176 176 176 176 172 175 175 176 176 170 162 150 146 + 152 126 159 166 156 167 164 164 173 167 160 163 160 160 114 148 + 149 81 40 47 43 56 52 36 50 62 53 63 58 38 74 144 + 150 69 19 16 16 19 16 16 16 16 16 16 16 17 56 150 + 137 62 22 19 22 24 24 29 30 16 24 11 21 26 68 150 + 134 90 102 125 130 124 111 101 92 110 134 116 94 112 96 136 + 140 132 164 173 176 176 164 118 126 165 172 172 170 154 113 131 + 162 164 176 176 176 166 148 83 90 145 166 176 176 160 108 141 + 160 176 176 176 158 129 70 44 28 77 128 167 176 148 98 144 + 160 176 176 176 160 152 140 158 153 142 154 166 176 118 94 144 + 160 176 176 176 167 175 173 174 176 176 176 172 148 60 77 142 + 158 174 168 168 171 176 174 176 176 173 156 123 88 77 105 142 + 158 171 166 168 168 176 168 168 173 172 172 170 172 168 167 143 + 138 143 148 156 147 160 164 166 151 148 151 152 155 156 168 140 + 131 146 140 150 152 140 140 142 143 152 148 143 140 137 149 132 + 146 160 160 163 165 160 160 160 160 160 160 160 160 164 158 147 + 136 142 160 163 160 160 160 164 160 160 160 160 160 160 141 138 + 144 108 156 152 153 156 152 160 160 147 157 154 152 154 110 136 + 139 64 38 47 42 53 52 42 48 47 50 53 48 30 66 136 + 150 58 16 16 16 16 16 16 16 16 16 16 16 16 48 129 + 137 53 16 16 16 11 22 19 16 16 14 7 22 21 58 130 + 132 81 96 111 120 108 107 85 76 102 120 108 96 103 80 120 + 136 132 164 161 164 164 162 104 114 159 160 160 160 150 97 124 + 150 152 164 161 164 166 146 70 84 142 160 160 160 144 84 139 + 148 160 160 160 150 126 60 32 26 75 114 160 160 136 82 144 + 152 160 160 160 152 142 130 150 144 138 139 160 160 112 80 144 + 154 160 160 160 160 160 164 164 166 160 164 166 136 52 68 144 + 160 161 161 160 160 160 160 160 160 160 154 108 72 65 96 138 + 160 161 162 160 160 160 160 160 160 160 160 160 160 160 156 130 + 142 139 142 154 147 152 152 158 150 140 144 155 151 150 152 136 + 136 150 140 158 148 144 149 136 144 152 144 143 140 142 158 134 + 152 168 160 160 168 172 171 162 162 172 160 168 170 164 166 151 + 160 143 158 160 166 162 166 165 162 169 160 172 166 160 144 146 + 160 104 152 156 157 158 164 160 160 154 149 164 160 148 110 142 + 153 62 26 47 50 54 52 34 48 59 48 54 54 32 62 136 + 155 50 9 16 16 16 12 15 16 16 16 16 16 16 48 151 + 138 50 14 16 10 12 10 14 16 12 14 16 15 20 50 156 + 134 75 96 119 120 104 114 79 76 106 120 116 94 109 76 135 + 142 121 164 162 160 160 170 104 110 158 163 160 160 150 89 127 + 158 148 160 166 160 163 144 67 74 142 173 160 160 148 82 143 + 156 160 160 160 148 117 61 24 20 70 119 157 160 142 76 144 + 160 170 160 160 158 143 131 146 144 138 135 157 160 116 73 132 + 160 161 165 164 163 162 162 160 160 160 164 162 132 41 57 133 + 161 164 160 160 166 162 174 160 160 160 156 109 68 61 92 134 + 163 165 164 160 160 160 172 162 166 160 160 160 160 158 158 135 + 140 139 146 151 148 148 160 162 148 142 144 146 151 146 156 142 + diff --git a/Utilidades/bin/python/Data/patt.g b/Utilidades/bin/python/Data/patt.g new file mode 100755 index 0000000..be7d282 --- /dev/null +++ b/Utilidades/bin/python/Data/patt.g @@ -0,0 +1,196 @@ + 120 126 132 128 136 129 113 114 105 105 105 109 109 113 120 103 + 161 168 163 161 151 112 75 68 72 77 60 105 147 148 124 138 + 147 160 158 129 52 27 75 141 157 162 133 78 50 35 91 146 + 143 160 122 28 20 51 157 166 170 166 176 173 115 29 103 150 + 148 150 49 17 22 113 161 169 170 167 163 163 172 78 96 148 + 145 101 16 16 37 155 173 172 167 160 160 165 163 132 113 155 + 138 53 16 21 59 158 169 168 174 166 169 165 166 160 160 139 + 135 20 13 19 62 161 170 170 169 171 166 160 160 160 160 142 + 142 27 16 12 66 170 172 176 170 174 155 158 155 164 160 142 + 141 22 11 18 57 162 169 167 161 124 94 75 72 66 68 108 + 161 64 16 14 34 161 171 165 160 156 146 34 16 16 90 136 + 145 117 12 19 39 154 168 160 163 169 171 22 15 14 104 140 + 150 150 70 12 8 93 163 167 162 161 160 38 16 12 101 131 + 161 167 155 74 19 19 124 166 169 164 164 36 18 17 114 137 + 152 160 169 169 119 49 35 64 100 105 87 40 62 76 139 139 + 151 154 150 160 150 148 127 111 103 116 116 128 144 164 162 139 + 97 114 121 114 120 117 100 109 100 99 101 99 97 100 108 97 + 139 157 160 159 147 111 67 62 65 71 56 101 136 137 111 133 + 141 160 160 131 57 16 58 121 144 152 124 67 29 25 96 134 + 133 158 122 33 15 35 149 160 160 160 160 160 84 14 103 138 + 144 147 47 9 10 103 160 160 154 160 155 160 151 66 93 145 + 132 98 15 16 33 150 160 160 160 160 160 160 157 129 104 144 + 139 48 11 15 50 157 160 160 160 160 160 156 158 153 152 154 + 141 32 12 16 59 160 160 160 160 160 160 154 160 160 158 136 + 136 20 10 16 65 156 160 160 160 160 154 158 155 157 156 135 + 134 29 16 16 58 155 160 160 160 121 84 69 67 62 60 88 + 137 57 9 14 36 159 160 160 160 153 137 17 14 14 84 128 + 136 126 19 11 28 139 158 160 156 160 152 20 14 13 102 140 + 140 155 79 12 10 90 152 160 160 159 145 39 16 12 106 140 + 148 160 152 68 14 24 118 156 160 160 162 34 10 11 107 133 + 147 160 160 156 104 42 21 58 94 100 72 24 46 74 130 123 + 142 152 152 160 145 147 125 111 99 105 106 129 141 152 148 129 + 110 114 121 122 126 120 104 104 100 94 96 98 98 103 108 107 + 143 159 160 160 151 117 80 72 68 71 56 105 136 145 119 144 + 141 159 157 129 54 18 61 121 144 152 122 58 29 18 81 144 + 130 153 121 33 9 39 147 159 160 160 156 159 89 11 91 134 + 128 141 43 16 19 113 152 154 160 160 160 159 153 67 88 137 + 134 104 18 2 19 137 158 160 160 156 160 160 156 118 109 131 + 139 52 16 9 37 146 160 160 160 158 160 160 159 160 144 136 + 129 28 16 10 47 151 160 158 156 160 160 160 160 159 156 143 + 142 31 15 10 51 157 160 157 159 160 154 160 156 156 155 154 + 156 37 9 1 51 158 160 160 160 117 94 73 78 68 65 91 + 154 59 10 15 49 153 159 160 160 154 144 29 16 5 73 122 + 152 124 16 15 25 136 157 160 160 160 158 27 7 1 90 127 + 147 153 71 8 5 108 158 160 160 160 148 27 10 2 98 127 + 143 155 152 70 15 24 118 156 155 156 150 27 9 17 112 133 + 137 153 149 152 107 51 27 57 94 100 78 29 42 70 132 139 + 135 154 147 155 151 152 126 104 94 105 110 124 141 158 152 145 + + 103 138 146 150 148 155 139 142 142 108 136 140 131 137 139 139 + 120 124 91 103 96 113 160 160 160 68 90 104 101 114 139 162 + 113 148 35 29 78 132 160 160 164 66 16 14 12 17 76 164 + 109 147 50 115 172 163 166 160 155 72 16 15 16 18 62 144 + 109 105 78 173 163 165 165 160 158 75 34 22 38 36 40 128 + 105 60 133 176 163 160 169 166 155 94 146 171 160 164 87 116 + 105 77 162 166 167 160 166 171 174 124 156 169 161 164 105 116 + 105 72 157 170 170 167 174 169 170 161 160 163 162 169 100 103 + 114 68 141 166 169 172 168 170 176 167 165 160 167 166 64 111 + 113 75 75 157 161 173 169 170 172 169 171 168 163 124 35 127 + 129 112 27 51 113 155 158 161 170 162 161 154 93 19 49 148 + 136 151 52 20 22 37 59 62 66 57 34 39 8 19 119 150 + 128 161 129 28 17 16 21 19 12 18 14 19 12 74 169 160 + 132 163 158 122 49 16 16 13 16 11 16 12 70 155 169 150 + 126 168 160 160 150 101 53 20 27 22 64 117 150 167 160 154 + 120 161 147 143 148 145 138 135 142 141 161 145 150 161 152 151 + 97 133 134 138 145 144 154 136 135 88 128 140 140 133 123 129 + 108 111 96 103 93 104 152 158 156 60 84 102 106 107 130 148 + 100 137 25 14 66 129 153 160 157 62 14 13 12 11 74 152 + 97 136 29 84 151 157 158 160 155 67 14 14 16 10 46 141 + 99 101 67 160 160 160 156 154 158 69 17 20 39 34 24 129 + 101 56 124 160 155 160 160 160 154 84 137 152 145 162 72 106 + 99 71 152 160 160 160 160 160 160 121 153 160 159 160 100 105 + 100 65 144 160 154 160 160 160 160 160 160 156 160 160 94 99 + 109 62 121 160 160 160 160 160 160 160 160 160 160 156 58 111 + 100 67 58 149 160 160 160 160 160 160 160 158 152 118 21 125 + 117 111 16 35 103 150 157 160 156 155 159 139 90 24 42 147 + 120 147 57 15 10 33 50 59 65 58 36 28 10 14 104 145 + 114 159 131 33 9 16 15 16 16 16 14 11 12 68 156 160 + 121 160 160 122 47 15 11 12 10 16 9 19 79 152 160 152 + 114 157 160 158 147 98 48 32 20 29 57 126 155 160 160 152 + 97 139 141 133 144 132 139 141 136 134 137 136 140 148 147 142 + 107 144 144 134 137 131 136 143 154 91 122 127 127 133 139 145 + 108 119 81 91 88 109 144 156 155 65 73 90 98 112 132 152 + 103 145 18 11 67 118 160 159 156 68 5 1 2 17 70 158 + 98 136 29 89 153 156 159 160 156 78 16 7 10 9 42 141 + 98 105 58 159 159 160 160 160 160 73 29 27 27 27 29 124 + 96 56 122 156 160 160 160 160 154 94 144 158 148 150 78 110 + 94 71 152 160 160 156 158 160 160 117 154 160 160 156 100 105 + 100 68 144 160 160 160 160 156 159 160 160 160 160 155 94 94 + 104 72 121 159 154 160 160 158 157 160 160 160 160 156 57 104 + 104 80 61 147 152 158 160 160 160 160 159 157 158 118 27 126 + 120 117 18 39 113 137 146 151 157 158 153 136 108 24 51 152 + 126 151 54 9 19 19 37 47 51 51 49 25 5 15 107 151 + 122 160 129 33 16 2 9 10 10 1 15 15 8 70 152 155 + 121 160 157 121 43 18 16 16 15 9 10 16 71 152 149 147 + 114 159 159 153 141 104 52 28 31 37 59 124 153 155 153 154 + 110 143 141 130 128 134 139 129 142 156 154 152 147 143 137 135 + + 139 162 164 144 128 116 116 103 111 127 148 150 160 150 154 151 + 139 139 76 62 40 87 105 100 64 35 49 119 169 169 160 152 + 137 114 17 18 36 164 164 169 166 124 19 19 74 155 167 161 + 131 101 12 16 38 160 161 162 167 163 93 8 12 70 150 150 + 140 104 14 15 22 171 169 163 160 168 154 39 19 12 117 145 + 136 90 16 16 34 146 156 160 165 171 161 34 14 16 64 161 + 108 68 66 72 75 94 124 161 167 169 162 57 18 11 22 141 + 142 160 164 155 158 155 174 170 176 172 170 66 12 16 27 142 + 142 160 160 160 160 166 171 169 170 170 161 62 19 13 20 135 + 139 160 160 166 165 169 166 174 168 169 158 59 21 16 53 138 + 155 113 132 163 165 160 160 167 172 173 155 37 16 16 101 145 + 148 96 78 172 163 163 167 170 169 161 113 22 17 49 150 148 + 150 103 29 115 173 176 166 170 166 157 51 20 28 122 160 143 + 146 91 35 50 78 133 162 157 141 75 27 52 129 158 160 147 + 138 124 148 147 105 60 77 72 68 75 112 151 161 163 168 161 + 103 120 113 109 109 105 105 105 114 113 129 136 128 132 126 120 + 129 148 152 141 129 106 105 99 111 125 147 145 160 152 152 142 + 123 130 74 46 24 72 100 94 58 21 42 104 156 160 160 147 + 133 107 11 10 34 162 160 160 156 118 24 14 68 152 160 148 + 140 106 12 16 39 145 159 160 160 152 90 10 12 79 155 140 + 140 102 13 14 20 152 160 156 160 158 139 28 11 19 126 136 + 128 84 14 14 17 137 153 160 160 160 159 36 14 9 57 137 + 88 60 62 67 69 84 121 160 160 160 155 58 16 16 29 134 + 135 156 157 155 158 154 160 160 160 160 156 65 16 10 20 136 + 136 158 160 160 154 160 160 160 160 160 160 59 16 12 32 141 + 154 152 153 158 156 160 160 160 160 160 157 50 15 11 48 139 + 144 104 129 157 160 160 160 160 160 160 150 33 16 15 98 132 + 145 93 66 151 160 155 160 154 160 160 103 10 9 47 147 144 + 138 103 14 84 160 160 160 160 160 149 35 15 33 122 158 133 + 134 96 25 29 67 124 152 144 121 58 16 57 131 160 160 141 + 133 111 137 136 101 56 71 65 62 67 111 147 159 160 157 139 + 97 108 100 97 99 101 99 100 109 100 117 120 114 121 114 97 + 145 152 158 141 124 110 105 94 104 126 152 151 155 147 154 135 + 139 132 70 42 29 78 100 94 57 27 51 107 152 149 153 137 + 133 112 17 9 27 150 156 155 156 118 24 15 70 152 155 143 + 127 98 2 10 27 148 160 160 160 158 108 5 8 71 153 147 + 127 90 1 7 27 158 160 160 160 157 136 25 15 16 124 152 + 122 73 5 16 29 144 154 160 160 159 153 49 15 10 59 154 + 91 65 68 78 73 94 117 160 160 160 158 51 1 9 37 156 + 154 155 156 156 160 154 160 159 157 160 157 51 10 15 31 142 + 143 156 159 160 160 160 160 156 158 160 151 47 10 16 28 129 + 136 144 160 159 160 160 158 160 160 160 146 37 9 16 52 139 + 131 109 118 156 160 160 156 160 160 158 137 19 2 18 104 134 + 137 88 67 153 159 160 160 160 154 152 113 19 16 43 141 128 + 134 91 11 89 159 156 160 160 159 147 39 9 33 121 153 130 + 144 81 18 29 58 122 152 144 121 61 18 54 129 157 159 141 + 144 119 145 136 105 56 71 68 72 80 117 151 160 160 159 143 + 107 108 103 98 98 96 94 100 104 104 120 126 122 121 114 110 + + 151 152 161 150 145 161 141 142 135 138 145 148 143 147 161 120 + 154 160 167 150 117 64 22 27 20 53 101 150 160 160 168 126 + 150 169 155 70 12 16 11 16 13 16 16 49 122 158 163 132 + 160 169 74 12 19 14 18 12 19 21 16 17 28 129 161 128 + 150 119 19 8 39 34 57 66 62 59 37 22 20 52 151 136 + 148 49 19 93 154 161 162 170 161 158 155 113 51 27 112 129 + 127 35 124 163 168 171 169 172 170 169 173 161 157 75 75 113 + 111 64 166 167 160 165 167 176 170 168 172 169 166 141 68 114 + 103 100 169 162 163 160 161 170 169 174 167 170 170 157 72 105 + 116 105 164 161 169 156 124 174 171 166 160 167 166 162 77 105 + 116 87 164 160 171 146 94 155 166 169 160 163 176 133 60 105 + 128 40 36 38 22 34 75 158 160 165 165 163 173 78 105 109 + 144 62 18 16 15 16 72 155 160 166 163 172 115 50 147 109 + 164 76 17 12 14 16 66 164 160 160 132 78 29 35 148 113 + 162 139 114 101 104 90 68 160 160 160 113 96 103 91 124 120 + 139 139 137 131 140 136 108 142 142 139 155 148 150 146 138 103 + 142 147 148 140 136 137 134 136 141 139 132 144 133 141 139 97 + 152 160 160 155 126 57 29 20 32 48 98 147 158 160 157 114 + 152 160 152 79 19 9 16 10 12 11 15 47 122 160 160 121 + 160 156 68 12 11 14 16 16 16 15 16 9 33 131 159 114 + 145 104 14 10 28 36 58 65 59 50 33 10 15 57 147 120 + 147 42 24 90 139 159 155 156 160 157 150 103 35 16 111 117 + 125 21 118 152 158 160 160 160 160 160 160 160 149 58 67 100 + 111 58 156 160 160 160 160 160 160 160 160 160 160 121 62 109 + 99 94 160 160 156 160 160 160 160 160 160 154 160 144 65 100 + 105 100 160 159 160 153 121 160 160 160 160 160 160 152 71 99 + 106 72 162 145 152 137 84 154 160 160 160 155 160 124 56 101 + 129 24 34 39 20 17 69 158 154 156 160 160 160 67 101 99 + 141 46 10 16 14 14 67 155 160 158 157 151 84 29 136 97 + 152 74 11 12 13 14 62 157 160 153 129 66 14 25 137 100 + 148 130 107 106 102 84 60 156 158 152 104 93 103 96 111 108 + 129 123 133 140 140 128 88 135 136 154 144 145 138 134 133 97 + 135 137 143 147 152 154 156 142 129 139 134 128 130 141 143 110 + 154 153 155 153 124 59 37 31 28 52 104 141 153 159 159 114 + 147 149 152 71 16 10 9 15 16 16 18 43 121 157 160 121 + 155 152 70 8 15 15 1 10 10 9 2 16 33 129 160 122 + 151 107 15 5 25 49 51 51 47 37 19 19 9 54 151 126 + 152 51 24 108 136 153 158 157 151 146 137 113 39 18 117 120 + 126 27 118 158 157 159 160 160 160 160 158 152 147 61 80 104 + 104 57 156 160 160 160 160 157 158 160 160 154 159 121 72 104 + 94 94 155 160 160 160 160 159 156 160 160 160 160 144 68 100 + 105 100 156 160 160 154 117 160 160 158 156 160 160 152 71 94 + 110 78 150 148 158 144 94 154 160 160 160 160 156 122 56 96 + 124 29 27 27 27 29 73 160 160 160 160 159 159 58 105 98 + 141 42 9 10 7 16 78 156 160 159 156 153 89 29 136 98 + 158 70 17 2 1 5 68 156 159 160 118 67 11 18 145 103 + 152 132 112 98 90 73 65 155 156 144 109 88 91 81 119 108 + 145 139 133 127 127 122 91 154 143 136 131 137 134 144 144 107 + diff --git a/Utilidades/bin/python/PuiModule.py b/Utilidades/bin/python/PuiModule.py new file mode 100644 index 0000000..e12a370 --- /dev/null +++ b/Utilidades/bin/python/PuiModule.py @@ -0,0 +1,351 @@ +# This file was automatically generated by SWIG (http://www.swig.org). +# Version 1.3.36 +# +# Don't modify this file, modify the SWIG interface instead. +# This file is compatible with both classic and new-style classes. + +import _PuiModule +import new +new_instancemethod = new.instancemethod +try: + _swig_property = property +except NameError: + pass # Python < 2.2 doesn't have 'property'. +def _swig_setattr_nondynamic(self,class_type,name,value,static=1): + if (name == "thisown"): return self.this.own(value) + if (name == "this"): + if type(value).__name__ == 'PySwigObject': + self.__dict__[name] = value + return + method = class_type.__swig_setmethods__.get(name,None) + if method: return method(self,value) + if (not static) or hasattr(self,name): + self.__dict__[name] = value + else: + raise AttributeError("You cannot add attributes to %s" % self) + +def _swig_setattr(self,class_type,name,value): + return _swig_setattr_nondynamic(self,class_type,name,value,0) + +def _swig_getattr(self,class_type,name): + if (name == "thisown"): return self.this.own() + method = class_type.__swig_getmethods__.get(name,None) + if method: return method(self) + raise AttributeError,name + +def _swig_repr(self): + try: strthis = "proxy of " + self.this.__repr__() + except: strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + +import types +try: + _object = types.ObjectType + _newclass = 1 +except AttributeError: + class _object : pass + _newclass = 0 +del types + + +class ARCoordMarcador(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, ARCoordMarcador, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, ARCoordMarcador, name) + __repr__ = _swig_repr + __swig_setmethods__["area"] = _PuiModule.ARCoordMarcador_area_set + __swig_getmethods__["area"] = _PuiModule.ARCoordMarcador_area_get + if _newclass:area = _swig_property(_PuiModule.ARCoordMarcador_area_get, _PuiModule.ARCoordMarcador_area_set) + __swig_setmethods__["centro"] = _PuiModule.ARCoordMarcador_centro_set + __swig_getmethods__["centro"] = _PuiModule.ARCoordMarcador_centro_get + if _newclass:centro = _swig_property(_PuiModule.ARCoordMarcador_centro_get, _PuiModule.ARCoordMarcador_centro_set) + __swig_setmethods__["vertex"] = _PuiModule.ARCoordMarcador_vertex_set + __swig_getmethods__["vertex"] = _PuiModule.ARCoordMarcador_vertex_get + if _newclass:vertex = _swig_property(_PuiModule.ARCoordMarcador_vertex_get, _PuiModule.ARCoordMarcador_vertex_set) + __swig_setmethods__["visible"] = _PuiModule.ARCoordMarcador_visible_set + __swig_getmethods__["visible"] = _PuiModule.ARCoordMarcador_visible_get + if _newclass:visible = _swig_property(_PuiModule.ARCoordMarcador_visible_get, _PuiModule.ARCoordMarcador_visible_set) + __swig_setmethods__["id"] = _PuiModule.ARCoordMarcador_id_set + __swig_getmethods__["id"] = _PuiModule.ARCoordMarcador_id_get + if _newclass:id = _swig_property(_PuiModule.ARCoordMarcador_id_get, _PuiModule.ARCoordMarcador_id_set) + __swig_setmethods__["cf"] = _PuiModule.ARCoordMarcador_cf_set + __swig_getmethods__["cf"] = _PuiModule.ARCoordMarcador_cf_get + if _newclass:cf = _swig_property(_PuiModule.ARCoordMarcador_cf_get, _PuiModule.ARCoordMarcador_cf_set) + def __init__(self, *args): + this = _PuiModule.new_ARCoordMarcador(*args) + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _PuiModule.delete_ARCoordMarcador + __del__ = lambda self : None; +ARCoordMarcador_swigregister = _PuiModule.ARCoordMarcador_swigregister +ARCoordMarcador_swigregister(ARCoordMarcador) + +class Elemento(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, Elemento, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, Elemento, name) + __repr__ = _swig_repr + __swig_setmethods__["idPatt"] = _PuiModule.Elemento_idPatt_set + __swig_getmethods__["idPatt"] = _PuiModule.Elemento_idPatt_get + if _newclass:idPatt = _swig_property(_PuiModule.Elemento_idPatt_get, _PuiModule.Elemento_idPatt_set) + __swig_setmethods__["imagen"] = _PuiModule.Elemento_imagen_set + __swig_getmethods__["imagen"] = _PuiModule.Elemento_imagen_get + if _newclass:imagen = _swig_property(_PuiModule.Elemento_imagen_get, _PuiModule.Elemento_imagen_set) + __swig_setmethods__["sonido"] = _PuiModule.Elemento_sonido_set + __swig_getmethods__["sonido"] = _PuiModule.Elemento_sonido_get + if _newclass:sonido = _swig_property(_PuiModule.Elemento_sonido_get, _PuiModule.Elemento_sonido_set) + __swig_setmethods__["nombre"] = _PuiModule.Elemento_nombre_set + __swig_getmethods__["nombre"] = _PuiModule.Elemento_nombre_get + if _newclass:nombre = _swig_property(_PuiModule.Elemento_nombre_get, _PuiModule.Elemento_nombre_set) + __swig_setmethods__["conjunto"] = _PuiModule.Elemento_conjunto_set + __swig_getmethods__["conjunto"] = _PuiModule.Elemento_conjunto_get + if _newclass:conjunto = _swig_property(_PuiModule.Elemento_conjunto_get, _PuiModule.Elemento_conjunto_set) + __swig_setmethods__["idElementoRelacionado"] = _PuiModule.Elemento_idElementoRelacionado_set + __swig_getmethods__["idElementoRelacionado"] = _PuiModule.Elemento_idElementoRelacionado_get + if _newclass:idElementoRelacionado = _swig_property(_PuiModule.Elemento_idElementoRelacionado_get, _PuiModule.Elemento_idElementoRelacionado_set) + __swig_setmethods__["nombreRelacion"] = _PuiModule.Elemento_nombreRelacion_set + __swig_getmethods__["nombreRelacion"] = _PuiModule.Elemento_nombreRelacion_get + if _newclass:nombreRelacion = _swig_property(_PuiModule.Elemento_nombreRelacion_get, _PuiModule.Elemento_nombreRelacion_set) + __swig_setmethods__["idImagenSDL"] = _PuiModule.Elemento_idImagenSDL_set + __swig_getmethods__["idImagenSDL"] = _PuiModule.Elemento_idImagenSDL_get + if _newclass:idImagenSDL = _swig_property(_PuiModule.Elemento_idImagenSDL_get, _PuiModule.Elemento_idImagenSDL_set) + def __init__(self, *args): + this = _PuiModule.new_Elemento(*args) + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _PuiModule.delete_Elemento + __del__ = lambda self : None; +Elemento_swigregister = _PuiModule.Elemento_swigregister +Elemento_swigregister(Elemento) + +class Historico(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, Historico, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, Historico, name) + __repr__ = _swig_repr + __swig_setmethods__["tope"] = _PuiModule.Historico_tope_set + __swig_getmethods__["tope"] = _PuiModule.Historico_tope_get + if _newclass:tope = _swig_property(_PuiModule.Historico_tope_get, _PuiModule.Historico_tope_set) + __swig_setmethods__["cantHistorico"] = _PuiModule.Historico_cantHistorico_set + __swig_getmethods__["cantHistorico"] = _PuiModule.Historico_cantHistorico_get + if _newclass:cantHistorico = _swig_property(_PuiModule.Historico_cantHistorico_get, _PuiModule.Historico_cantHistorico_set) + __swig_setmethods__["historicoElementos"] = _PuiModule.Historico_historicoElementos_set + __swig_getmethods__["historicoElementos"] = _PuiModule.Historico_historicoElementos_get + if _newclass:historicoElementos = _swig_property(_PuiModule.Historico_historicoElementos_get, _PuiModule.Historico_historicoElementos_set) + def __init__(self, *args): + this = _PuiModule.new_Historico(*args) + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _PuiModule.delete_Historico + __del__ = lambda self : None; +Historico_swigregister = _PuiModule.Historico_swigregister +Historico_swigregister(Historico) + +class RangosColorApuntador(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, RangosColorApuntador, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, RangosColorApuntador, name) + __repr__ = _swig_repr + __swig_setmethods__["hmin"] = _PuiModule.RangosColorApuntador_hmin_set + __swig_getmethods__["hmin"] = _PuiModule.RangosColorApuntador_hmin_get + if _newclass:hmin = _swig_property(_PuiModule.RangosColorApuntador_hmin_get, _PuiModule.RangosColorApuntador_hmin_set) + __swig_setmethods__["hmax"] = _PuiModule.RangosColorApuntador_hmax_set + __swig_getmethods__["hmax"] = _PuiModule.RangosColorApuntador_hmax_get + if _newclass:hmax = _swig_property(_PuiModule.RangosColorApuntador_hmax_get, _PuiModule.RangosColorApuntador_hmax_set) + __swig_setmethods__["smin"] = _PuiModule.RangosColorApuntador_smin_set + __swig_getmethods__["smin"] = _PuiModule.RangosColorApuntador_smin_get + if _newclass:smin = _swig_property(_PuiModule.RangosColorApuntador_smin_get, _PuiModule.RangosColorApuntador_smin_set) + __swig_setmethods__["smax"] = _PuiModule.RangosColorApuntador_smax_set + __swig_getmethods__["smax"] = _PuiModule.RangosColorApuntador_smax_get + if _newclass:smax = _swig_property(_PuiModule.RangosColorApuntador_smax_get, _PuiModule.RangosColorApuntador_smax_set) + __swig_setmethods__["vmin"] = _PuiModule.RangosColorApuntador_vmin_set + __swig_getmethods__["vmin"] = _PuiModule.RangosColorApuntador_vmin_get + if _newclass:vmin = _swig_property(_PuiModule.RangosColorApuntador_vmin_get, _PuiModule.RangosColorApuntador_vmin_set) + __swig_setmethods__["vmax"] = _PuiModule.RangosColorApuntador_vmax_set + __swig_getmethods__["vmax"] = _PuiModule.RangosColorApuntador_vmax_get + if _newclass:vmax = _swig_property(_PuiModule.RangosColorApuntador_vmax_get, _PuiModule.RangosColorApuntador_vmax_set) + def __init__(self, *args): + this = _PuiModule.new_RangosColorApuntador(*args) + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _PuiModule.delete_RangosColorApuntador + __del__ = lambda self : None; +RangosColorApuntador_swigregister = _PuiModule.RangosColorApuntador_swigregister +RangosColorApuntador_swigregister(RangosColorApuntador) + +class ResultadosCalibracion(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, ResultadosCalibracion, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, ResultadosCalibracion, name) + __repr__ = _swig_repr + __swig_setmethods__["areas_minimas"] = _PuiModule.ResultadosCalibracion_areas_minimas_set + __swig_getmethods__["areas_minimas"] = _PuiModule.ResultadosCalibracion_areas_minimas_get + if _newclass:areas_minimas = _swig_property(_PuiModule.ResultadosCalibracion_areas_minimas_get, _PuiModule.ResultadosCalibracion_areas_minimas_set) + __swig_setmethods__["areas_maximas"] = _PuiModule.ResultadosCalibracion_areas_maximas_set + __swig_getmethods__["areas_maximas"] = _PuiModule.ResultadosCalibracion_areas_maximas_get + if _newclass:areas_maximas = _swig_property(_PuiModule.ResultadosCalibracion_areas_maximas_get, _PuiModule.ResultadosCalibracion_areas_maximas_set) + __swig_setmethods__["relaciones_promedio"] = _PuiModule.ResultadosCalibracion_relaciones_promedio_set + __swig_getmethods__["relaciones_promedio"] = _PuiModule.ResultadosCalibracion_relaciones_promedio_get + if _newclass:relaciones_promedio = _swig_property(_PuiModule.ResultadosCalibracion_relaciones_promedio_get, _PuiModule.ResultadosCalibracion_relaciones_promedio_set) + def __init__(self, *args): + this = _PuiModule.new_ResultadosCalibracion(*args) + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _PuiModule.delete_ResultadosCalibracion + __del__ = lambda self : None; +ResultadosCalibracion_swigregister = _PuiModule.ResultadosCalibracion_swigregister +ResultadosCalibracion_swigregister(ResultadosCalibracion) + +class CoordApuntador(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, CoordApuntador, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, CoordApuntador, name) + __repr__ = _swig_repr + __swig_setmethods__["area"] = _PuiModule.CoordApuntador_area_set + __swig_getmethods__["area"] = _PuiModule.CoordApuntador_area_get + if _newclass:area = _swig_property(_PuiModule.CoordApuntador_area_get, _PuiModule.CoordApuntador_area_set) + __swig_setmethods__["centro"] = _PuiModule.CoordApuntador_centro_set + __swig_getmethods__["centro"] = _PuiModule.CoordApuntador_centro_get + if _newclass:centro = _swig_property(_PuiModule.CoordApuntador_centro_get, _PuiModule.CoordApuntador_centro_set) + def __init__(self, *args): + this = _PuiModule.new_CoordApuntador(*args) + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _PuiModule.delete_CoordApuntador + __del__ = lambda self : None; +CoordApuntador_swigregister = _PuiModule.CoordApuntador_swigregister +CoordApuntador_swigregister(CoordApuntador) + +FORMA_APUNTADOR_CIRCULO = _PuiModule.FORMA_APUNTADOR_CIRCULO +FORMA_APUNTADOR_RECTANGULAR = _PuiModule.FORMA_APUNTADOR_RECTANGULAR +FORMA_APUNTADOR_MANO = _PuiModule.FORMA_APUNTADOR_MANO +ERROR_DETECTANDO_MARCADORES = _PuiModule.ERROR_DETECTANDO_MARCADORES +ERROR_CALCULANDO_MATRIZ_TRANSFORMACION = _PuiModule.ERROR_CALCULANDO_MATRIZ_TRANSFORMACION +ERROR_NINGUN_MARCADOR_DETECTADO = _PuiModule.ERROR_NINGUN_MARCADOR_DETECTADO +ERROR_IMAGEN_NULL = _PuiModule.ERROR_IMAGEN_NULL +DETECCION_CORRECTA = _PuiModule.DETECCION_CORRECTA +MASCARA_APLICADA = _PuiModule.MASCARA_APLICADA +MASCARA_NO_APLICADA = _PuiModule.MASCARA_NO_APLICADA +TIPO_MASCARA_BINARIA = _PuiModule.TIPO_MASCARA_BINARIA +TIPO_MASCARA_ATENUANTE = _PuiModule.TIPO_MASCARA_ATENUANTE +ERROR_TOMAR_MUESTRA_FORMA_NO_IMPLEMENTADA = _PuiModule.ERROR_TOMAR_MUESTRA_FORMA_NO_IMPLEMENTADA +ERROR_TOMAR_MUESTRA_OK = _PuiModule.ERROR_TOMAR_MUESTRA_OK +OFFSET_ROI = _PuiModule.OFFSET_ROI +MIN_AREA_WIDTH_HEIGHT = _PuiModule.MIN_AREA_WIDTH_HEIGHT +MIN_CF_MARKER_DETECT = _PuiModule.MIN_CF_MARKER_DETECT +MODO_MULTI_MARKERS = _PuiModule.MODO_MULTI_MARKERS +MODO_SIMPLE = _PuiModule.MODO_SIMPLE +MODO_MULTI_MARKERS_CALIBRADOR = _PuiModule.MODO_MULTI_MARKERS_CALIBRADOR +class Pui(_object): + __swig_setmethods__ = {} + __setattr__ = lambda self, name, value: _swig_setattr(self, Pui, name, value) + __swig_getmethods__ = {} + __getattr__ = lambda self, name: _swig_getattr(self, Pui, name) + __repr__ = _swig_repr + FAST_SPEED_LOOP = _PuiModule.Pui_FAST_SPEED_LOOP + NORMAL_SPEED_LOOP = _PuiModule.Pui_NORMAL_SPEED_LOOP + FAST_SPEED_LOOP_MULTIPLIER = _PuiModule.Pui_FAST_SPEED_LOOP_MULTIPLIER + NORMAL_SPEED_LOOP_MULTIPLIER = _PuiModule.Pui_NORMAL_SPEED_LOOP_MULTIPLIER + def insert(*args): return _PuiModule.Pui_insert(*args) + def out(*args): return _PuiModule.Pui_out(*args) + def __init__(self, *args): + this = _PuiModule.new_Pui(*args) + try: self.this.append(this) + except: self.this = this + __swig_destroy__ = _PuiModule.delete_Pui + __del__ = lambda self : None; + def leerConfiguracionObjetosPUI(*args): return _PuiModule.Pui_leerConfiguracionObjetosPUI(*args) + def leerPatternsModoSimple(*args): return _PuiModule.Pui_leerPatternsModoSimple(*args) + def imprimirPropiedadesObjetosPUI(*args): return _PuiModule.Pui_imprimirPropiedadesObjetosPUI(*args) + def getNombreObjetoPUI(*args): return _PuiModule.Pui_getNombreObjetoPUI(*args) + def getSonidoObjetoPUI(*args): return _PuiModule.Pui_getSonidoObjetoPUI(*args) + def getImagenObjetoPUI(*args): return _PuiModule.Pui_getImagenObjetoPUI(*args) + def getSonidoError(*args): return _PuiModule.Pui_getSonidoError(*args) + def getSonidoOk(*args): return _PuiModule.Pui_getSonidoOk(*args) + def esRelacionCorrecta(*args): return _PuiModule.Pui_esRelacionCorrecta(*args) + def getConjuntoObjetoPui(*args): return _PuiModule.Pui_getConjuntoObjetoPui(*args) + def getIdElementoRelacionado(*args): return _PuiModule.Pui_getIdElementoRelacionado(*args) + def getNombreRelacionObjetoPUI(*args): return _PuiModule.Pui_getNombreRelacionObjetoPUI(*args) + def detectarSeleccion(*args): return _PuiModule.Pui_detectarSeleccion(*args) + def initDeteccionApuntador(*args): return _PuiModule.Pui_initDeteccionApuntador(*args) + def getPropiedadesDeteccionApuntador(*args): return _PuiModule.Pui_getPropiedadesDeteccionApuntador(*args) + def setPropiedadesDeteccionApuntador(*args): return _PuiModule.Pui_setPropiedadesDeteccionApuntador(*args) + def getPropiedadesColorApuntador(*args): return _PuiModule.Pui_getPropiedadesColorApuntador(*args) + def setPropiedadesColorApuntador(*args): return _PuiModule.Pui_setPropiedadesColorApuntador(*args) + def setHminApuntador(*args): return _PuiModule.Pui_setHminApuntador(*args) + def getHminApuntador(*args): return _PuiModule.Pui_getHminApuntador(*args) + def setHmaxApuntador(*args): return _PuiModule.Pui_setHmaxApuntador(*args) + def getHmaxApuntador(*args): return _PuiModule.Pui_getHmaxApuntador(*args) + def setSminApuntador(*args): return _PuiModule.Pui_setSminApuntador(*args) + def getSminApuntador(*args): return _PuiModule.Pui_getSminApuntador(*args) + def setSmaxApuntador(*args): return _PuiModule.Pui_setSmaxApuntador(*args) + def getSmaxApuntador(*args): return _PuiModule.Pui_getSmaxApuntador(*args) + def setVminApuntador(*args): return _PuiModule.Pui_setVminApuntador(*args) + def getVminApuntador(*args): return _PuiModule.Pui_getVminApuntador(*args) + def setVmaxApuntador(*args): return _PuiModule.Pui_setVmaxApuntador(*args) + def getVmaxApuntador(*args): return _PuiModule.Pui_getVmaxApuntador(*args) + def procesarDatosCalibracion(*args): return _PuiModule.Pui_procesarDatosCalibracion(*args) + def guardarDatosCalibracion(*args): return _PuiModule.Pui_guardarDatosCalibracion(*args) + def initPropiedadesCalibracion(*args): return _PuiModule.Pui_initPropiedadesCalibracion(*args) + def leerConfiguracionCalibracion(*args): return _PuiModule.Pui_leerConfiguracionCalibracion(*args) + def calibrarThreshold(*args): return _PuiModule.Pui_calibrarThreshold(*args) + def setBrillo(*args): return _PuiModule.Pui_setBrillo(*args) + def setAutoWhiteBalance(*args): return _PuiModule.Pui_setAutoWhiteBalance(*args) + def setAutoGain(*args): return _PuiModule.Pui_setAutoGain(*args) + def setHorizontalFlip(*args): return _PuiModule.Pui_setHorizontalFlip(*args) + def abrirVentanaGrafica(*args): return _PuiModule.Pui_abrirVentanaGrafica(*args) + def cerrarVentanaGrafica(*args): return _PuiModule.Pui_cerrarVentanaGrafica(*args) + def desplegarImagenAR(*args): return _PuiModule.Pui_desplegarImagenAR(*args) + def desplegarImagenFromData(*args): return _PuiModule.Pui_desplegarImagenFromData(*args) + def capNext(*args): return _PuiModule.Pui_capNext(*args) + def capStart(*args): return _PuiModule.Pui_capStart(*args) + def capStop(*args): return _PuiModule.Pui_capStop(*args) + def capClose(*args): return _PuiModule.Pui_capClose(*args) + def capturarImagenAR(*args): return _PuiModule.Pui_capturarImagenAR(*args) + def capturarPyImageAR(*args): return _PuiModule.Pui_capturarPyImageAR(*args) + def obtenerImagenDebugAR(*args): return _PuiModule.Pui_obtenerImagenDebugAR(*args) + def initPropiedadesCalibracionSoloApuntador(*args): return _PuiModule.Pui_initPropiedadesCalibracionSoloApuntador(*args) + def aplicarNuevaMascaraCalibrador(*args): return _PuiModule.Pui_aplicarNuevaMascaraCalibrador(*args) + def aplicarMascaraCalibrador(*args): return _PuiModule.Pui_aplicarMascaraCalibrador(*args) + def setAchicarRadioMascaraCircular(*args): return _PuiModule.Pui_setAchicarRadioMascaraCircular(*args) + def getAchicarRadioMascaraCircular(*args): return _PuiModule.Pui_getAchicarRadioMascaraCircular(*args) + def getCalibrationImage(*args): return _PuiModule.Pui_getCalibrationImage(*args) + def tomarMuestraApuntador(*args): return _PuiModule.Pui_tomarMuestraApuntador(*args) + def calcularResultadosCalibracionApuntador(*args): return _PuiModule.Pui_calcularResultadosCalibracionApuntador(*args) + def guardarSoloRangosColorApuntador(*args): return _PuiModule.Pui_guardarSoloRangosColorApuntador(*args) + def guardarCalibracionApuntador(*args): return _PuiModule.Pui_guardarCalibracionApuntador(*args) + def setDebugCalibracion(*args): return _PuiModule.Pui_setDebugCalibracion(*args) + def isDebugCalibracion(*args): return _PuiModule.Pui_isDebugCalibracion(*args) + def getResultadosRangosColor(*args): return _PuiModule.Pui_getResultadosRangosColor(*args) + def detectarYCalcularPosicionTodosMultiMarkers(*args): return _PuiModule.Pui_detectarYCalcularPosicionTodosMultiMarkers(*args) + def detectarMarcadores(*args): return _PuiModule.Pui_detectarMarcadores(*args) + def detectarMarcadoresSimple(*args): return _PuiModule.Pui_detectarMarcadoresSimple(*args) + def getIdMarcadorSimpleDetectado(*args): return _PuiModule.Pui_getIdMarcadorSimpleDetectado(*args) + def getMarcadorSimpleDetectado(*args): return _PuiModule.Pui_getMarcadorSimpleDetectado(*args) + def getInfoMultiMarcador(*args): return _PuiModule.Pui_getInfoMultiMarcador(*args) + def setARCf(*args): return _PuiModule.Pui_setARCf(*args) + def getARCf(*args): return _PuiModule.Pui_getARCf(*args) + def getARThreshold(*args): return _PuiModule.Pui_getARThreshold(*args) + def setARThreshold(*args): return _PuiModule.Pui_setARThreshold(*args) + def initPuiConCapturaDeVideo(*args): return _PuiModule.Pui_initPuiConCapturaDeVideo(*args) + def setDebugConImagenes(*args): return _PuiModule.Pui_setDebugConImagenes(*args) + def getDebugConImagenes(*args): return _PuiModule.Pui_getDebugConImagenes(*args) + def habilitarHistorico(*args): return _PuiModule.Pui_habilitarHistorico(*args) + def isHistoricoHabilitado(*args): return _PuiModule.Pui_isHistoricoHabilitado(*args) + def finish(*args): return _PuiModule.Pui_finish(*args) + def getFPSAndResetCount(*args): return _PuiModule.Pui_getFPSAndResetCount(*args) + def getFPS(*args): return _PuiModule.Pui_getFPS(*args) + def getModuleInfo(*args): return _PuiModule.Pui_getModuleInfo(*args) + def setDebugMode(*args): return _PuiModule.Pui_setDebugMode(*args) + def getDebugMode(*args): return _PuiModule.Pui_getDebugMode(*args) +Pui_swigregister = _PuiModule.Pui_swigregister +Pui_swigregister(Pui) + + + diff --git a/Utilidades/bin/python/PuiModule.pyc b/Utilidades/bin/python/PuiModule.pyc Binary files differnew file mode 100644 index 0000000..70f54c6 --- /dev/null +++ b/Utilidades/bin/python/PuiModule.pyc diff --git a/Utilidades/bin/python/Pui_wrap.cxx b/Utilidades/bin/python/Pui_wrap.cxx new file mode 100644 index 0000000..9f6bda5 --- /dev/null +++ b/Utilidades/bin/python/Pui_wrap.cxx @@ -0,0 +1,9772 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 1.3.36 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + +#define SWIGPYTHON +#define SWIG_PYTHON_DIRECTOR_NO_VTABLE + +#ifdef __cplusplus +template<typename T> class SwigValueWrapper { + T *tt; +public: + SwigValueWrapper() : tt(0) { } + SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { } + SwigValueWrapper(const T& t) : tt(new T(t)) { } + ~SwigValueWrapper() { delete tt; } + SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; } + operator T&() const { return *tt; } + T *operator&() { return tt; } +private: + SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs); +}; + +template <typename T> T SwigValueInit() { + return T(); +} +#endif + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIG_MSC_UNSUPPRESS_4505 +# if defined(_MSC_VER) +# pragma warning(disable : 4505) /* unreferenced local function has been removed */ +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + + + +/* Python.h has to appear first */ +#include <Python.h> + +/* ----------------------------------------------------------------------------- + * swigrun.swg + * + * This file contains generic CAPI SWIG runtime support for pointer + * type checking. + * ----------------------------------------------------------------------------- */ + +/* This should only be incremented when either the layout of swig_type_info changes, + or for whatever reason, the runtime changes incompatibly */ +#define SWIG_RUNTIME_VERSION "4" + +/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ +#ifdef SWIG_TYPE_TABLE +# define SWIG_QUOTE_STRING(x) #x +# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) +# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) +#else +# define SWIG_TYPE_TABLE_NAME +#endif + +/* + You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for + creating a static or dynamic library from the swig runtime code. + In 99.9% of the cases, swig just needs to declare them as 'static'. + + But only do this if is strictly necessary, ie, if you have problems + with your compiler or so. +*/ + +#ifndef SWIGRUNTIME +# define SWIGRUNTIME SWIGINTERN +#endif + +#ifndef SWIGRUNTIMEINLINE +# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE +#endif + +/* Generic buffer size */ +#ifndef SWIG_BUFFER_SIZE +# define SWIG_BUFFER_SIZE 1024 +#endif + +/* Flags for pointer conversions */ +#define SWIG_POINTER_DISOWN 0x1 +#define SWIG_CAST_NEW_MEMORY 0x2 + +/* Flags for new pointer objects */ +#define SWIG_POINTER_OWN 0x1 + + +/* + Flags/methods for returning states. + + The swig conversion methods, as ConvertPtr, return and integer + that tells if the conversion was successful or not. And if not, + an error code can be returned (see swigerrors.swg for the codes). + + Use the following macros/flags to set or process the returning + states. + + In old swig versions, you usually write code as: + + if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { + // success code + } else { + //fail code + } + + Now you can be more explicit as: + + int res = SWIG_ConvertPtr(obj,vptr,ty.flags); + if (SWIG_IsOK(res)) { + // success code + } else { + // fail code + } + + that seems to be the same, but now you can also do + + Type *ptr; + int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); + if (SWIG_IsOK(res)) { + // success code + if (SWIG_IsNewObj(res) { + ... + delete *ptr; + } else { + ... + } + } else { + // fail code + } + + I.e., now SWIG_ConvertPtr can return new objects and you can + identify the case and take care of the deallocation. Of course that + requires also to SWIG_ConvertPtr to return new result values, as + + int SWIG_ConvertPtr(obj, ptr,...) { + if (<obj is ok>) { + if (<need new object>) { + *ptr = <ptr to new allocated object>; + return SWIG_NEWOBJ; + } else { + *ptr = <ptr to old object>; + return SWIG_OLDOBJ; + } + } else { + return SWIG_BADOBJ; + } + } + + Of course, returning the plain '0(success)/-1(fail)' still works, but you can be + more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the + swig errors code. + + Finally, if the SWIG_CASTRANK_MODE is enabled, the result code + allows to return the 'cast rank', for example, if you have this + + int food(double) + int fooi(int); + + and you call + + food(1) // cast rank '1' (1 -> 1.0) + fooi(1) // cast rank '0' + + just use the SWIG_AddCast()/SWIG_CheckState() + + + */ +#define SWIG_OK (0) +#define SWIG_ERROR (-1) +#define SWIG_IsOK(r) (r >= 0) +#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) + +/* The CastRankLimit says how many bits are used for the cast rank */ +#define SWIG_CASTRANKLIMIT (1 << 8) +/* The NewMask denotes the object was created (using new/malloc) */ +#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) +/* The TmpMask is for in/out typemaps that use temporal objects */ +#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) +/* Simple returning values */ +#define SWIG_BADOBJ (SWIG_ERROR) +#define SWIG_OLDOBJ (SWIG_OK) +#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) +#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) +/* Check, add and del mask methods */ +#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) +#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) +#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) +#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) +#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) +#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) + + +/* Cast-Rank Mode */ +#if defined(SWIG_CASTRANK_MODE) +# ifndef SWIG_TypeRank +# define SWIG_TypeRank unsigned long +# endif +# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ +# define SWIG_MAXCASTRANK (2) +# endif +# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) +# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) +SWIGINTERNINLINE int SWIG_AddCast(int r) { + return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; +} +SWIGINTERNINLINE int SWIG_CheckState(int r) { + return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; +} +#else /* no cast-rank mode */ +# define SWIG_AddCast +# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) +#endif + + + + +#include <string.h> + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void *(*swig_converter_func)(void *, int *); +typedef struct swig_type_info *(*swig_dycast_func)(void **); + +/* Structure to store information on one type */ +typedef struct swig_type_info { + const char *name; /* mangled name of this type */ + const char *str; /* human readable name of this type */ + swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ + struct swig_cast_info *cast; /* linked list of types that can cast into this type */ + void *clientdata; /* language specific type data */ + int owndata; /* flag if the structure owns the clientdata */ +} swig_type_info; + +/* Structure to store a type and conversion function used for casting */ +typedef struct swig_cast_info { + swig_type_info *type; /* pointer to type that is equivalent to this type */ + swig_converter_func converter; /* function to cast the void pointers */ + struct swig_cast_info *next; /* pointer to next cast in linked list */ + struct swig_cast_info *prev; /* pointer to the previous cast */ +} swig_cast_info; + +/* Structure used to store module information + * Each module generates one structure like this, and the runtime collects + * all of these structures and stores them in a circularly linked list.*/ +typedef struct swig_module_info { + swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ + size_t size; /* Number of types in this module */ + struct swig_module_info *next; /* Pointer to next element in circularly linked list */ + swig_type_info **type_initial; /* Array of initially generated type structures */ + swig_cast_info **cast_initial; /* Array of initially generated casting structures */ + void *clientdata; /* Language specific module data */ +} swig_module_info; + +/* + Compare two type names skipping the space characters, therefore + "char*" == "char *" and "Class<int>" == "Class<int >", etc. + + Return 0 when the two name types are equivalent, as in + strncmp, but skipping ' '. +*/ +SWIGRUNTIME int +SWIG_TypeNameComp(const char *f1, const char *l1, + const char *f2, const char *l2) { + for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { + while ((*f1 == ' ') && (f1 != l1)) ++f1; + while ((*f2 == ' ') && (f2 != l2)) ++f2; + if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; + } + return (int)((l1 - f1) - (l2 - f2)); +} + +/* + Check type equivalence in a name list like <name1>|<name2>|... + Return 0 if not equal, 1 if equal +*/ +SWIGRUNTIME int +SWIG_TypeEquiv(const char *nb, const char *tb) { + int equiv = 0; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (!equiv && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; + if (*ne) ++ne; + } + return equiv; +} + +/* + Check type equivalence in a name list like <name1>|<name2>|... + Return 0 if equal, -1 if nb < tb, 1 if nb > tb +*/ +SWIGRUNTIME int +SWIG_TypeCompare(const char *nb, const char *tb) { + int equiv = 0; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (!equiv && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; + if (*ne) ++ne; + } + return equiv; +} + + +/* think of this as a c++ template<> or a scheme macro */ +#define SWIG_TypeCheck_Template(comparison, ty) \ + if (ty) { \ + swig_cast_info *iter = ty->cast; \ + while (iter) { \ + if (comparison) { \ + if (iter == ty->cast) return iter; \ + /* Move iter to the top of the linked list */ \ + iter->prev->next = iter->next; \ + if (iter->next) \ + iter->next->prev = iter->prev; \ + iter->next = ty->cast; \ + iter->prev = 0; \ + if (ty->cast) ty->cast->prev = iter; \ + ty->cast = iter; \ + return iter; \ + } \ + iter = iter->next; \ + } \ + } \ + return 0 + +/* + Check the typename +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheck(const char *c, swig_type_info *ty) { + SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty); +} + +/* Same as previous function, except strcmp is replaced with a pointer comparison */ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) { + SWIG_TypeCheck_Template(iter->type == from, into); +} + +/* + Cast a pointer up an inheritance hierarchy +*/ +SWIGRUNTIMEINLINE void * +SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { + return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); +} + +/* + Dynamic pointer casting. Down an inheritance hierarchy +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { + swig_type_info *lastty = ty; + if (!ty || !ty->dcast) return ty; + while (ty && (ty->dcast)) { + ty = (*ty->dcast)(ptr); + if (ty) lastty = ty; + } + return lastty; +} + +/* + Return the name associated with this type +*/ +SWIGRUNTIMEINLINE const char * +SWIG_TypeName(const swig_type_info *ty) { + return ty->name; +} + +/* + Return the pretty name associated with this type, + that is an unmangled type name in a form presentable to the user. +*/ +SWIGRUNTIME const char * +SWIG_TypePrettyName(const swig_type_info *type) { + /* The "str" field contains the equivalent pretty names of the + type, separated by vertical-bar characters. We choose + to print the last name, as it is often (?) the most + specific. */ + if (!type) return NULL; + if (type->str != NULL) { + const char *last_name = type->str; + const char *s; + for (s = type->str; *s; s++) + if (*s == '|') last_name = s+1; + return last_name; + } + else + return type->name; +} + +/* + Set the clientdata field for a type +*/ +SWIGRUNTIME void +SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { + swig_cast_info *cast = ti->cast; + /* if (ti->clientdata == clientdata) return; */ + ti->clientdata = clientdata; + + while (cast) { + if (!cast->converter) { + swig_type_info *tc = cast->type; + if (!tc->clientdata) { + SWIG_TypeClientData(tc, clientdata); + } + } + cast = cast->next; + } +} +SWIGRUNTIME void +SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { + SWIG_TypeClientData(ti, clientdata); + ti->owndata = 1; +} + +/* + Search for a swig_type_info structure only by mangled name + Search is a O(log #types) + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_MangledTypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + swig_module_info *iter = start; + do { + if (iter->size) { + register size_t l = 0; + register size_t r = iter->size - 1; + do { + /* since l+r >= 0, we can (>> 1) instead (/ 2) */ + register size_t i = (l + r) >> 1; + const char *iname = iter->types[i]->name; + if (iname) { + register int compare = strcmp(name, iname); + if (compare == 0) { + return iter->types[i]; + } else if (compare < 0) { + if (i) { + r = i - 1; + } else { + break; + } + } else if (compare > 0) { + l = i + 1; + } + } else { + break; /* should never happen */ + } + } while (l <= r); + } + iter = iter->next; + } while (iter != end); + return 0; +} + +/* + Search for a swig_type_info structure for either a mangled name or a human readable name. + It first searches the mangled names of the types, which is a O(log #types) + If a type is not found it then searches the human readable names, which is O(#types). + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + /* STEP 1: Search the name field using binary search */ + swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); + if (ret) { + return ret; + } else { + /* STEP 2: If the type hasn't been found, do a complete search + of the str field (the human readable name) */ + swig_module_info *iter = start; + do { + register size_t i = 0; + for (; i < iter->size; ++i) { + if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) + return iter->types[i]; + } + iter = iter->next; + } while (iter != end); + } + + /* neither found a match */ + return 0; +} + +/* + Pack binary data into a string +*/ +SWIGRUNTIME char * +SWIG_PackData(char *c, void *ptr, size_t sz) { + static const char hex[17] = "0123456789abcdef"; + register const unsigned char *u = (unsigned char *) ptr; + register const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + register unsigned char uu = *u; + *(c++) = hex[(uu & 0xf0) >> 4]; + *(c++) = hex[uu & 0xf]; + } + return c; +} + +/* + Unpack binary data from a string +*/ +SWIGRUNTIME const char * +SWIG_UnpackData(const char *c, void *ptr, size_t sz) { + register unsigned char *u = (unsigned char *) ptr; + register const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + register char d = *(c++); + register unsigned char uu; + if ((d >= '0') && (d <= '9')) + uu = ((d - '0') << 4); + else if ((d >= 'a') && (d <= 'f')) + uu = ((d - ('a'-10)) << 4); + else + return (char *) 0; + d = *(c++); + if ((d >= '0') && (d <= '9')) + uu |= (d - '0'); + else if ((d >= 'a') && (d <= 'f')) + uu |= (d - ('a'-10)); + else + return (char *) 0; + *u = uu; + } + return c; +} + +/* + Pack 'void *' into a string buffer. +*/ +SWIGRUNTIME char * +SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { + char *r = buff; + if ((2*sizeof(void *) + 2) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,&ptr,sizeof(void *)); + if (strlen(name) + 1 > (bsz - (r - buff))) return 0; + strcpy(r,name); + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + *ptr = (void *) 0; + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sizeof(void *)); +} + +SWIGRUNTIME char * +SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { + char *r = buff; + size_t lname = (name ? strlen(name) : 0); + if ((2*sz + 2 + lname) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,ptr,sz); + if (lname) { + strncpy(r,name,lname+1); + } else { + *r = 0; + } + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + memset(ptr,0,sz); + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sz); +} + +#ifdef __cplusplus +} +#endif + +/* Errors in SWIG */ +#define SWIG_UnknownError -1 +#define SWIG_IOError -2 +#define SWIG_RuntimeError -3 +#define SWIG_IndexError -4 +#define SWIG_TypeError -5 +#define SWIG_DivisionByZero -6 +#define SWIG_OverflowError -7 +#define SWIG_SyntaxError -8 +#define SWIG_ValueError -9 +#define SWIG_SystemError -10 +#define SWIG_AttributeError -11 +#define SWIG_MemoryError -12 +#define SWIG_NullReferenceError -13 + + + + +/* Add PyOS_snprintf for old Pythons */ +#if PY_VERSION_HEX < 0x02020000 +# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM) +# define PyOS_snprintf _snprintf +# else +# define PyOS_snprintf snprintf +# endif +#endif + +/* A crude PyString_FromFormat implementation for old Pythons */ +#if PY_VERSION_HEX < 0x02020000 + +#ifndef SWIG_PYBUFFER_SIZE +# define SWIG_PYBUFFER_SIZE 1024 +#endif + +static PyObject * +PyString_FromFormat(const char *fmt, ...) { + va_list ap; + char buf[SWIG_PYBUFFER_SIZE * 2]; + int res; + va_start(ap, fmt); + res = vsnprintf(buf, sizeof(buf), fmt, ap); + va_end(ap); + return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf); +} +#endif + +/* Add PyObject_Del for old Pythons */ +#if PY_VERSION_HEX < 0x01060000 +# define PyObject_Del(op) PyMem_DEL((op)) +#endif +#ifndef PyObject_DEL +# define PyObject_DEL PyObject_Del +#endif + +/* A crude PyExc_StopIteration exception for old Pythons */ +#if PY_VERSION_HEX < 0x02020000 +# ifndef PyExc_StopIteration +# define PyExc_StopIteration PyExc_RuntimeError +# endif +# ifndef PyObject_GenericGetAttr +# define PyObject_GenericGetAttr 0 +# endif +#endif +/* Py_NotImplemented is defined in 2.1 and up. */ +#if PY_VERSION_HEX < 0x02010000 +# ifndef Py_NotImplemented +# define Py_NotImplemented PyExc_RuntimeError +# endif +#endif + + +/* A crude PyString_AsStringAndSize implementation for old Pythons */ +#if PY_VERSION_HEX < 0x02010000 +# ifndef PyString_AsStringAndSize +# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;} +# endif +#endif + +/* PySequence_Size for old Pythons */ +#if PY_VERSION_HEX < 0x02000000 +# ifndef PySequence_Size +# define PySequence_Size PySequence_Length +# endif +#endif + + +/* PyBool_FromLong for old Pythons */ +#if PY_VERSION_HEX < 0x02030000 +static +PyObject *PyBool_FromLong(long ok) +{ + PyObject *result = ok ? Py_True : Py_False; + Py_INCREF(result); + return result; +} +#endif + +/* Py_ssize_t for old Pythons */ +/* This code is as recommended by: */ +/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */ +#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN) +typedef int Py_ssize_t; +# define PY_SSIZE_T_MAX INT_MAX +# define PY_SSIZE_T_MIN INT_MIN +#endif + +/* ----------------------------------------------------------------------------- + * error manipulation + * ----------------------------------------------------------------------------- */ + +SWIGRUNTIME PyObject* +SWIG_Python_ErrorType(int code) { + PyObject* type = 0; + switch(code) { + case SWIG_MemoryError: + type = PyExc_MemoryError; + break; + case SWIG_IOError: + type = PyExc_IOError; + break; + case SWIG_RuntimeError: + type = PyExc_RuntimeError; + break; + case SWIG_IndexError: + type = PyExc_IndexError; + break; + case SWIG_TypeError: + type = PyExc_TypeError; + break; + case SWIG_DivisionByZero: + type = PyExc_ZeroDivisionError; + break; + case SWIG_OverflowError: + type = PyExc_OverflowError; + break; + case SWIG_SyntaxError: + type = PyExc_SyntaxError; + break; + case SWIG_ValueError: + type = PyExc_ValueError; + break; + case SWIG_SystemError: + type = PyExc_SystemError; + break; + case SWIG_AttributeError: + type = PyExc_AttributeError; + break; + default: + type = PyExc_RuntimeError; + } + return type; +} + + +SWIGRUNTIME void +SWIG_Python_AddErrorMsg(const char* mesg) +{ + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + + if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback); + if (value) { + PyObject *old_str = PyObject_Str(value); + PyErr_Clear(); + Py_XINCREF(type); + PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg); + Py_DECREF(old_str); + Py_DECREF(value); + } else { + PyErr_SetString(PyExc_RuntimeError, mesg); + } +} + + + +#if defined(SWIG_PYTHON_NO_THREADS) +# if defined(SWIG_PYTHON_THREADS) +# undef SWIG_PYTHON_THREADS +# endif +#endif +#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ +# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) +# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */ +# define SWIG_PYTHON_USE_GIL +# endif +# endif +# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ +# ifndef SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() +# endif +# ifdef __cplusplus /* C++ code */ + class SWIG_Python_Thread_Block { + bool status; + PyGILState_STATE state; + public: + void end() { if (status) { PyGILState_Release(state); status = false;} } + SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} + ~SWIG_Python_Thread_Block() { end(); } + }; + class SWIG_Python_Thread_Allow { + bool status; + PyThreadState *save; + public: + void end() { if (status) { PyEval_RestoreThread(save); status = false; }} + SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} + ~SWIG_Python_Thread_Allow() { end(); } + }; +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block +# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow +# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() +# else /* C code */ +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() +# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() +# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) +# endif +# else /* Old thread way, not implemented, user must provide it */ +# if !defined(SWIG_PYTHON_INITIALIZE_THREADS) +# define SWIG_PYTHON_INITIALIZE_THREADS +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_END_BLOCK) +# define SWIG_PYTHON_THREAD_END_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# endif +# if !defined(SWIG_PYTHON_THREAD_END_ALLOW) +# define SWIG_PYTHON_THREAD_END_ALLOW +# endif +# endif +#else /* No thread support */ +# define SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# define SWIG_PYTHON_THREAD_END_BLOCK +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# define SWIG_PYTHON_THREAD_END_ALLOW +#endif + +/* ----------------------------------------------------------------------------- + * Python API portion that goes into the runtime + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#if 0 +} /* cc-mode */ +#endif +#endif + +/* ----------------------------------------------------------------------------- + * Constant declarations + * ----------------------------------------------------------------------------- */ + +/* Constant Types */ +#define SWIG_PY_POINTER 4 +#define SWIG_PY_BINARY 5 + +/* Constant information structure */ +typedef struct swig_const_info { + int type; + char *name; + long lvalue; + double dvalue; + void *pvalue; + swig_type_info **ptype; +} swig_const_info; + +#ifdef __cplusplus +#if 0 +{ /* cc-mode */ +#endif +} +#endif + + +/* ----------------------------------------------------------------------------- + * See the LICENSE file for information on copyright, usage and redistribution + * of SWIG, and the README file for authors - http://www.swig.org/release.html. + * + * pyrun.swg + * + * This file contains the runtime support for Python modules + * and includes code for managing global variables and pointer + * type checking. + * + * ----------------------------------------------------------------------------- */ + +/* Common SWIG API */ + +/* for raw pointers */ +#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) +#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) +#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags) +#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) +#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) +#define swig_owntype int + +/* for raw packed data */ +#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + +/* for class or struct pointers */ +#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) +#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) + +/* for C or C++ function pointers */ +#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) +#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0) + +/* for C++ member pointers, ie, member methods */ +#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + + +/* Runtime API */ + +#define SWIG_GetModule(clientdata) SWIG_Python_GetModule() +#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) +#define SWIG_NewClientData(obj) PySwigClientData_New(obj) + +#define SWIG_SetErrorObj SWIG_Python_SetErrorObj +#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg +#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) +#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) +#define SWIG_fail goto fail + + +/* Runtime API implementation */ + +/* Error manipulation */ + +SWIGINTERN void +SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetObject(errtype, obj); + Py_DECREF(obj); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +SWIGINTERN void +SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetString(errtype, (char *) msg); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) + +/* Set a constant value */ + +SWIGINTERN void +SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { + PyDict_SetItemString(d, (char*) name, obj); + Py_DECREF(obj); +} + +/* Append a value to the result obj */ + +SWIGINTERN PyObject* +SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { +#if !defined(SWIG_PYTHON_OUTPUT_TUPLE) + if (!result) { + result = obj; + } else if (result == Py_None) { + Py_DECREF(result); + result = obj; + } else { + if (!PyList_Check(result)) { + PyObject *o2 = result; + result = PyList_New(1); + PyList_SetItem(result, 0, o2); + } + PyList_Append(result,obj); + Py_DECREF(obj); + } + return result; +#else + PyObject* o2; + PyObject* o3; + if (!result) { + result = obj; + } else if (result == Py_None) { + Py_DECREF(result); + result = obj; + } else { + if (!PyTuple_Check(result)) { + o2 = result; + result = PyTuple_New(1); + PyTuple_SET_ITEM(result, 0, o2); + } + o3 = PyTuple_New(1); + PyTuple_SET_ITEM(o3, 0, obj); + o2 = result; + result = PySequence_Concat(o2, o3); + Py_DECREF(o2); + Py_DECREF(o3); + } + return result; +#endif +} + +/* Unpack the argument tuple */ + +SWIGINTERN int +SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs) +{ + if (!args) { + if (!min && !max) { + return 1; + } else { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", + name, (min == max ? "" : "at least "), (int)min); + return 0; + } + } + if (!PyTuple_Check(args)) { + PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); + return 0; + } else { + register Py_ssize_t l = PyTuple_GET_SIZE(args); + if (l < min) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at least "), (int)min, (int)l); + return 0; + } else if (l > max) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at most "), (int)max, (int)l); + return 0; + } else { + register int i; + for (i = 0; i < l; ++i) { + objs[i] = PyTuple_GET_ITEM(args, i); + } + for (; l < max; ++l) { + objs[l] = 0; + } + return i + 1; + } + } +} + +/* A functor is a function object with one single object argument */ +#if PY_VERSION_HEX >= 0x02020000 +#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); +#else +#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj); +#endif + +/* + Helper for static pointer initialization for both C and C++ code, for example + static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); +*/ +#ifdef __cplusplus +#define SWIG_STATIC_POINTER(var) var +#else +#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var +#endif + +/* ----------------------------------------------------------------------------- + * Pointer declarations + * ----------------------------------------------------------------------------- */ + +/* Flags for new pointer objects */ +#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) +#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) + +#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) + +#ifdef __cplusplus +extern "C" { +#if 0 +} /* cc-mode */ +#endif +#endif + +/* How to access Py_None */ +#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# ifndef SWIG_PYTHON_NO_BUILD_NONE +# ifndef SWIG_PYTHON_BUILD_NONE +# define SWIG_PYTHON_BUILD_NONE +# endif +# endif +#endif + +#ifdef SWIG_PYTHON_BUILD_NONE +# ifdef Py_None +# undef Py_None +# define Py_None SWIG_Py_None() +# endif +SWIGRUNTIMEINLINE PyObject * +_SWIG_Py_None(void) +{ + PyObject *none = Py_BuildValue((char*)""); + Py_DECREF(none); + return none; +} +SWIGRUNTIME PyObject * +SWIG_Py_None(void) +{ + static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None(); + return none; +} +#endif + +/* The python void return value */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Py_Void(void) +{ + PyObject *none = Py_None; + Py_INCREF(none); + return none; +} + +/* PySwigClientData */ + +typedef struct { + PyObject *klass; + PyObject *newraw; + PyObject *newargs; + PyObject *destroy; + int delargs; + int implicitconv; +} PySwigClientData; + +SWIGRUNTIMEINLINE int +SWIG_Python_CheckImplicit(swig_type_info *ty) +{ + PySwigClientData *data = (PySwigClientData *)ty->clientdata; + return data ? data->implicitconv : 0; +} + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_ExceptionType(swig_type_info *desc) { + PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0; + PyObject *klass = data ? data->klass : 0; + return (klass ? klass : PyExc_RuntimeError); +} + + +SWIGRUNTIME PySwigClientData * +PySwigClientData_New(PyObject* obj) +{ + if (!obj) { + return 0; + } else { + PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData)); + /* the klass element */ + data->klass = obj; + Py_INCREF(data->klass); + /* the newraw method and newargs arguments used to create a new raw instance */ + if (PyClass_Check(obj)) { + data->newraw = 0; + data->newargs = obj; + Py_INCREF(obj); + } else { +#if (PY_VERSION_HEX < 0x02020000) + data->newraw = 0; +#else + data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__"); +#endif + if (data->newraw) { + Py_INCREF(data->newraw); + data->newargs = PyTuple_New(1); + PyTuple_SetItem(data->newargs, 0, obj); + } else { + data->newargs = obj; + } + Py_INCREF(data->newargs); + } + /* the destroy method, aka as the C++ delete method */ + data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__"); + if (PyErr_Occurred()) { + PyErr_Clear(); + data->destroy = 0; + } + if (data->destroy) { + int flags; + Py_INCREF(data->destroy); + flags = PyCFunction_GET_FLAGS(data->destroy); +#ifdef METH_O + data->delargs = !(flags & (METH_O)); +#else + data->delargs = 0; +#endif + } else { + data->delargs = 0; + } + data->implicitconv = 0; + return data; + } +} + +SWIGRUNTIME void +PySwigClientData_Del(PySwigClientData* data) +{ + Py_XDECREF(data->newraw); + Py_XDECREF(data->newargs); + Py_XDECREF(data->destroy); +} + +/* =============== PySwigObject =====================*/ + +typedef struct { + PyObject_HEAD + void *ptr; + swig_type_info *ty; + int own; + PyObject *next; +} PySwigObject; + +SWIGRUNTIME PyObject * +PySwigObject_long(PySwigObject *v) +{ + return PyLong_FromVoidPtr(v->ptr); +} + +SWIGRUNTIME PyObject * +PySwigObject_format(const char* fmt, PySwigObject *v) +{ + PyObject *res = NULL; + PyObject *args = PyTuple_New(1); + if (args) { + if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) { + PyObject *ofmt = PyString_FromString(fmt); + if (ofmt) { + res = PyString_Format(ofmt,args); + Py_DECREF(ofmt); + } + Py_DECREF(args); + } + } + return res; +} + +SWIGRUNTIME PyObject * +PySwigObject_oct(PySwigObject *v) +{ + return PySwigObject_format("%o",v); +} + +SWIGRUNTIME PyObject * +PySwigObject_hex(PySwigObject *v) +{ + return PySwigObject_format("%x",v); +} + +SWIGRUNTIME PyObject * +#ifdef METH_NOARGS +PySwigObject_repr(PySwigObject *v) +#else +PySwigObject_repr(PySwigObject *v, PyObject *args) +#endif +{ + const char *name = SWIG_TypePrettyName(v->ty); + PyObject *hex = PySwigObject_hex(v); + PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex)); + Py_DECREF(hex); + if (v->next) { +#ifdef METH_NOARGS + PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next); +#else + PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args); +#endif + PyString_ConcatAndDel(&repr,nrep); + } + return repr; +} + +SWIGRUNTIME int +PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) +{ +#ifdef METH_NOARGS + PyObject *repr = PySwigObject_repr(v); +#else + PyObject *repr = PySwigObject_repr(v, NULL); +#endif + if (repr) { + fputs(PyString_AsString(repr), fp); + Py_DECREF(repr); + return 0; + } else { + return 1; + } +} + +SWIGRUNTIME PyObject * +PySwigObject_str(PySwigObject *v) +{ + char result[SWIG_BUFFER_SIZE]; + return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ? + PyString_FromString(result) : 0; +} + +SWIGRUNTIME int +PySwigObject_compare(PySwigObject *v, PySwigObject *w) +{ + void *i = v->ptr; + void *j = w->ptr; + return (i < j) ? -1 : ((i > j) ? 1 : 0); +} + +SWIGRUNTIME PyTypeObject* _PySwigObject_type(void); + +SWIGRUNTIME PyTypeObject* +PySwigObject_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type(); + return type; +} + +SWIGRUNTIMEINLINE int +PySwigObject_Check(PyObject *op) { + return ((op)->ob_type == PySwigObject_type()) + || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0); +} + +SWIGRUNTIME PyObject * +PySwigObject_New(void *ptr, swig_type_info *ty, int own); + +SWIGRUNTIME void +PySwigObject_dealloc(PyObject *v) +{ + PySwigObject *sobj = (PySwigObject *) v; + PyObject *next = sobj->next; + if (sobj->own == SWIG_POINTER_OWN) { + swig_type_info *ty = sobj->ty; + PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0; + PyObject *destroy = data ? data->destroy : 0; + if (destroy) { + /* destroy is always a VARARGS method */ + PyObject *res; + if (data->delargs) { + /* we need to create a temporal object to carry the destroy operation */ + PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0); + res = SWIG_Python_CallFunctor(destroy, tmp); + Py_DECREF(tmp); + } else { + PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); + PyObject *mself = PyCFunction_GET_SELF(destroy); + res = ((*meth)(mself, v)); + } + Py_XDECREF(res); + } +#if !defined(SWIG_PYTHON_SILENT_MEMLEAK) + else { + const char *name = SWIG_TypePrettyName(ty); + printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown")); + } +#endif + } + Py_XDECREF(next); + PyObject_DEL(v); +} + +SWIGRUNTIME PyObject* +PySwigObject_append(PyObject* v, PyObject* next) +{ + PySwigObject *sobj = (PySwigObject *) v; +#ifndef METH_O + PyObject *tmp = 0; + if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL; + next = tmp; +#endif + if (!PySwigObject_Check(next)) { + return NULL; + } + sobj->next = next; + Py_INCREF(next); + return SWIG_Py_Void(); +} + +SWIGRUNTIME PyObject* +#ifdef METH_NOARGS +PySwigObject_next(PyObject* v) +#else +PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +#endif +{ + PySwigObject *sobj = (PySwigObject *) v; + if (sobj->next) { + Py_INCREF(sobj->next); + return sobj->next; + } else { + return SWIG_Py_Void(); + } +} + +SWIGINTERN PyObject* +#ifdef METH_NOARGS +PySwigObject_disown(PyObject *v) +#else +PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +#endif +{ + PySwigObject *sobj = (PySwigObject *)v; + sobj->own = 0; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +#ifdef METH_NOARGS +PySwigObject_acquire(PyObject *v) +#else +PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +#endif +{ + PySwigObject *sobj = (PySwigObject *)v; + sobj->own = SWIG_POINTER_OWN; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +PySwigObject_own(PyObject *v, PyObject *args) +{ + PyObject *val = 0; +#if (PY_VERSION_HEX < 0x02020000) + if (!PyArg_ParseTuple(args,(char *)"|O:own",&val)) +#else + if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) +#endif + { + return NULL; + } + else + { + PySwigObject *sobj = (PySwigObject *)v; + PyObject *obj = PyBool_FromLong(sobj->own); + if (val) { +#ifdef METH_NOARGS + if (PyObject_IsTrue(val)) { + PySwigObject_acquire(v); + } else { + PySwigObject_disown(v); + } +#else + if (PyObject_IsTrue(val)) { + PySwigObject_acquire(v,args); + } else { + PySwigObject_disown(v,args); + } +#endif + } + return obj; + } +} + +#ifdef METH_O +static PyMethodDef +swigobject_methods[] = { + {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"}, + {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"}, + {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, + {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"}, + {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"}, + {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"}, + {0, 0, 0, 0} +}; +#else +static PyMethodDef +swigobject_methods[] = { + {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"}, + {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"}, + {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"}, + {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"}, + {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"}, + {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"}, + {0, 0, 0, 0} +}; +#endif + +#if PY_VERSION_HEX < 0x02020000 +SWIGINTERN PyObject * +PySwigObject_getattr(PySwigObject *sobj,char *name) +{ + return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name); +} +#endif + +SWIGRUNTIME PyTypeObject* +_PySwigObject_type(void) { + static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; + + static PyNumberMethods PySwigObject_as_number = { + (binaryfunc)0, /*nb_add*/ + (binaryfunc)0, /*nb_subtract*/ + (binaryfunc)0, /*nb_multiply*/ + (binaryfunc)0, /*nb_divide*/ + (binaryfunc)0, /*nb_remainder*/ + (binaryfunc)0, /*nb_divmod*/ + (ternaryfunc)0,/*nb_power*/ + (unaryfunc)0, /*nb_negative*/ + (unaryfunc)0, /*nb_positive*/ + (unaryfunc)0, /*nb_absolute*/ + (inquiry)0, /*nb_nonzero*/ + 0, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + 0, /*nb_and*/ + 0, /*nb_xor*/ + 0, /*nb_or*/ + (coercion)0, /*nb_coerce*/ + (unaryfunc)PySwigObject_long, /*nb_int*/ + (unaryfunc)PySwigObject_long, /*nb_long*/ + (unaryfunc)0, /*nb_float*/ + (unaryfunc)PySwigObject_oct, /*nb_oct*/ + (unaryfunc)PySwigObject_hex, /*nb_hex*/ +#if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */ +#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ +#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */ + 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */ +#endif + }; + + static PyTypeObject pyswigobject_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp + = { + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ + (char *)"PySwigObject", /* tp_name */ + sizeof(PySwigObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)PySwigObject_dealloc, /* tp_dealloc */ + (printfunc)PySwigObject_print, /* tp_print */ +#if PY_VERSION_HEX < 0x02020000 + (getattrfunc)PySwigObject_getattr, /* tp_getattr */ +#else + (getattrfunc)0, /* tp_getattr */ +#endif + (setattrfunc)0, /* tp_setattr */ + (cmpfunc)PySwigObject_compare, /* tp_compare */ + (reprfunc)PySwigObject_repr, /* tp_repr */ + &PySwigObject_as_number, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + (reprfunc)PySwigObject_str, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigobject_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ +#if PY_VERSION_HEX >= 0x02020000 + 0, /* tp_iter */ + 0, /* tp_iternext */ + swigobject_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ +#endif +#if PY_VERSION_HEX >= 0x02030000 + 0, /* tp_del */ +#endif +#ifdef COUNT_ALLOCS + 0,0,0,0 /* tp_alloc -> tp_next */ +#endif + }; + pyswigobject_type = tmp; + pyswigobject_type.ob_type = &PyType_Type; + type_init = 1; + } + return &pyswigobject_type; +} + +SWIGRUNTIME PyObject * +PySwigObject_New(void *ptr, swig_type_info *ty, int own) +{ + PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type()); + if (sobj) { + sobj->ptr = ptr; + sobj->ty = ty; + sobj->own = own; + sobj->next = 0; + } + return (PyObject *)sobj; +} + +/* ----------------------------------------------------------------------------- + * Implements a simple Swig Packed type, and use it instead of string + * ----------------------------------------------------------------------------- */ + +typedef struct { + PyObject_HEAD + void *pack; + swig_type_info *ty; + size_t size; +} PySwigPacked; + +SWIGRUNTIME int +PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags)) +{ + char result[SWIG_BUFFER_SIZE]; + fputs("<Swig Packed ", fp); + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { + fputs("at ", fp); + fputs(result, fp); + } + fputs(v->ty->name,fp); + fputs(">", fp); + return 0; +} + +SWIGRUNTIME PyObject * +PySwigPacked_repr(PySwigPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { + return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name); + } else { + return PyString_FromFormat("<Swig Packed %s>", v->ty->name); + } +} + +SWIGRUNTIME PyObject * +PySwigPacked_str(PySwigPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ + return PyString_FromFormat("%s%s", result, v->ty->name); + } else { + return PyString_FromString(v->ty->name); + } +} + +SWIGRUNTIME int +PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w) +{ + size_t i = v->size; + size_t j = w->size; + int s = (i < j) ? -1 : ((i > j) ? 1 : 0); + return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size); +} + +SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void); + +SWIGRUNTIME PyTypeObject* +PySwigPacked_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type(); + return type; +} + +SWIGRUNTIMEINLINE int +PySwigPacked_Check(PyObject *op) { + return ((op)->ob_type == _PySwigPacked_type()) + || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0); +} + +SWIGRUNTIME void +PySwigPacked_dealloc(PyObject *v) +{ + if (PySwigPacked_Check(v)) { + PySwigPacked *sobj = (PySwigPacked *) v; + free(sobj->pack); + } + PyObject_DEL(v); +} + +SWIGRUNTIME PyTypeObject* +_PySwigPacked_type(void) { + static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; + static PyTypeObject pyswigpacked_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp + = { + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ + (char *)"PySwigPacked", /* tp_name */ + sizeof(PySwigPacked), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)PySwigPacked_dealloc, /* tp_dealloc */ + (printfunc)PySwigPacked_print, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ + (cmpfunc)PySwigPacked_compare, /* tp_compare */ + (reprfunc)PySwigPacked_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + (reprfunc)PySwigPacked_str, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigpacked_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ +#if PY_VERSION_HEX >= 0x02020000 + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ +#endif +#if PY_VERSION_HEX >= 0x02030000 + 0, /* tp_del */ +#endif +#ifdef COUNT_ALLOCS + 0,0,0,0 /* tp_alloc -> tp_next */ +#endif + }; + pyswigpacked_type = tmp; + pyswigpacked_type.ob_type = &PyType_Type; + type_init = 1; + } + return &pyswigpacked_type; +} + +SWIGRUNTIME PyObject * +PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty) +{ + PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type()); + if (sobj) { + void *pack = malloc(size); + if (pack) { + memcpy(pack, ptr, size); + sobj->pack = pack; + sobj->ty = ty; + sobj->size = size; + } else { + PyObject_DEL((PyObject *) sobj); + sobj = 0; + } + } + return (PyObject *) sobj; +} + +SWIGRUNTIME swig_type_info * +PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size) +{ + if (PySwigPacked_Check(obj)) { + PySwigPacked *sobj = (PySwigPacked *)obj; + if (sobj->size != size) return 0; + memcpy(ptr, sobj->pack, size); + return sobj->ty; + } else { + return 0; + } +} + +/* ----------------------------------------------------------------------------- + * pointers/data manipulation + * ----------------------------------------------------------------------------- */ + +SWIGRUNTIMEINLINE PyObject * +_SWIG_This(void) +{ + return PyString_FromString("this"); +} + +SWIGRUNTIME PyObject * +SWIG_This(void) +{ + static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This(); + return swig_this; +} + +/* #define SWIG_PYTHON_SLOW_GETSET_THIS */ + +SWIGRUNTIME PySwigObject * +SWIG_Python_GetSwigThis(PyObject *pyobj) +{ + if (PySwigObject_Check(pyobj)) { + return (PySwigObject *) pyobj; + } else { + PyObject *obj = 0; +#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000)) + if (PyInstance_Check(pyobj)) { + obj = _PyInstance_Lookup(pyobj, SWIG_This()); + } else { + PyObject **dictptr = _PyObject_GetDictPtr(pyobj); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; + } else { +#ifdef PyWeakref_CheckProxy + if (PyWeakref_CheckProxy(pyobj)) { + PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); + return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; + } +#endif + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } + } + } +#else + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } +#endif + if (obj && !PySwigObject_Check(obj)) { + /* a PyObject is called 'this', try to get the 'real this' + PySwigObject from it */ + return SWIG_Python_GetSwigThis(obj); + } + return (PySwigObject *)obj; + } +} + +/* Acquire a pointer value */ + +SWIGRUNTIME int +SWIG_Python_AcquirePtr(PyObject *obj, int own) { + if (own == SWIG_POINTER_OWN) { + PySwigObject *sobj = SWIG_Python_GetSwigThis(obj); + if (sobj) { + int oldown = sobj->own; + sobj->own = own; + return oldown; + } + } + return 0; +} + +/* Convert a pointer value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { + if (!obj) return SWIG_ERROR; + if (obj == Py_None) { + if (ptr) *ptr = 0; + return SWIG_OK; + } else { + PySwigObject *sobj = SWIG_Python_GetSwigThis(obj); + if (own) + *own = 0; + while (sobj) { + void *vptr = sobj->ptr; + if (ty) { + swig_type_info *to = sobj->ty; + if (to == ty) { + /* no type cast needed */ + if (ptr) *ptr = vptr; + break; + } else { + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) { + sobj = (PySwigObject *)sobj->next; + } else { + if (ptr) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc,vptr,&newmemory); + if (newmemory == SWIG_CAST_NEW_MEMORY) { + assert(own); + if (own) + *own = *own | SWIG_CAST_NEW_MEMORY; + } + } + break; + } + } + } else { + if (ptr) *ptr = vptr; + break; + } + } + if (sobj) { + if (own) + *own = *own | sobj->own; + if (flags & SWIG_POINTER_DISOWN) { + sobj->own = 0; + } + return SWIG_OK; + } else { + int res = SWIG_ERROR; + if (flags & SWIG_POINTER_IMPLICIT_CONV) { + PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0; + if (data && !data->implicitconv) { + PyObject *klass = data->klass; + if (klass) { + PyObject *impconv; + data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ + impconv = SWIG_Python_CallFunctor(klass, obj); + data->implicitconv = 0; + if (PyErr_Occurred()) { + PyErr_Clear(); + impconv = 0; + } + if (impconv) { + PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv); + if (iobj) { + void *vptr; + res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); + if (SWIG_IsOK(res)) { + if (ptr) { + *ptr = vptr; + /* transfer the ownership to 'ptr' */ + iobj->own = 0; + res = SWIG_AddCast(res); + res = SWIG_AddNewMask(res); + } else { + res = SWIG_AddCast(res); + } + } + } + Py_DECREF(impconv); + } + } + } + } + return res; + } + } +} + +/* Convert a function ptr value */ + +SWIGRUNTIME int +SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { + if (!PyCFunction_Check(obj)) { + return SWIG_ConvertPtr(obj, ptr, ty, 0); + } else { + void *vptr = 0; + + /* here we get the method pointer for callbacks */ + const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); + const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; + if (desc) { + desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; + if (!desc) return SWIG_ERROR; + } + if (ty) { + swig_cast_info *tc = SWIG_TypeCheck(desc,ty); + if (tc) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc,vptr,&newmemory); + assert(!newmemory); /* newmemory handling not yet implemented */ + } else { + return SWIG_ERROR; + } + } else { + *ptr = vptr; + } + return SWIG_OK; + } +} + +/* Convert a packed value value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { + swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz); + if (!to) return SWIG_ERROR; + if (ty) { + if (to != ty) { + /* check type cast? */ + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) return SWIG_ERROR; + } + } + return SWIG_OK; +} + +/* ----------------------------------------------------------------------------- + * Create a new pointer object + * ----------------------------------------------------------------------------- */ + +/* + Create a new instance object, whitout calling __init__, and set the + 'this' attribute. +*/ + +SWIGRUNTIME PyObject* +SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this) +{ +#if (PY_VERSION_HEX >= 0x02020000) + PyObject *inst = 0; + PyObject *newraw = data->newraw; + if (newraw) { + inst = PyObject_Call(newraw, data->newargs, NULL); + if (inst) { +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + PyDict_SetItem(dict, SWIG_This(), swig_this); + } + } +#else + PyObject *key = SWIG_This(); + PyObject_SetAttr(inst, key, swig_this); +#endif + } + } else { + PyObject *dict = PyDict_New(); + PyDict_SetItem(dict, SWIG_This(), swig_this); + inst = PyInstance_NewRaw(data->newargs, dict); + Py_DECREF(dict); + } + return inst; +#else +#if (PY_VERSION_HEX >= 0x02010000) + PyObject *inst; + PyObject *dict = PyDict_New(); + PyDict_SetItem(dict, SWIG_This(), swig_this); + inst = PyInstance_NewRaw(data->newargs, dict); + Py_DECREF(dict); + return (PyObject *) inst; +#else + PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type); + if (inst == NULL) { + return NULL; + } + inst->in_class = (PyClassObject *)data->newargs; + Py_INCREF(inst->in_class); + inst->in_dict = PyDict_New(); + if (inst->in_dict == NULL) { + Py_DECREF(inst); + return NULL; + } +#ifdef Py_TPFLAGS_HAVE_WEAKREFS + inst->in_weakreflist = NULL; +#endif +#ifdef Py_TPFLAGS_GC + PyObject_GC_Init(inst); +#endif + PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this); + return (PyObject *) inst; +#endif +#endif +} + +SWIGRUNTIME void +SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) +{ + PyObject *dict; +#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + } + PyDict_SetItem(dict, SWIG_This(), swig_this); + return; + } +#endif + dict = PyObject_GetAttrString(inst, (char*)"__dict__"); + PyDict_SetItem(dict, SWIG_This(), swig_this); + Py_DECREF(dict); +} + + +SWIGINTERN PyObject * +SWIG_Python_InitShadowInstance(PyObject *args) { + PyObject *obj[2]; + if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) { + return NULL; + } else { + PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]); + if (sthis) { + PySwigObject_append((PyObject*) sthis, obj[1]); + } else { + SWIG_Python_SetSwigThis(obj[0], obj[1]); + } + return SWIG_Py_Void(); + } +} + +/* Create a new pointer object */ + +SWIGRUNTIME PyObject * +SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) { + if (!ptr) { + return SWIG_Py_Void(); + } else { + int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; + PyObject *robj = PySwigObject_New(ptr, type, own); + PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0; + if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { + PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); + if (inst) { + Py_DECREF(robj); + robj = inst; + } + } + return robj; + } +} + +/* Create a new packed object */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { + return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); +} + +/* -----------------------------------------------------------------------------* + * Get type list + * -----------------------------------------------------------------------------*/ + +#ifdef SWIG_LINK_RUNTIME +void *SWIG_ReturnGlobalTypeList(void *); +#endif + +SWIGRUNTIME swig_module_info * +SWIG_Python_GetModule(void) { + static void *type_pointer = (void *)0; + /* first check if module already created */ + if (!type_pointer) { +#ifdef SWIG_LINK_RUNTIME + type_pointer = SWIG_ReturnGlobalTypeList((void *)0); +#else + type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, + (char*)"type_pointer" SWIG_TYPE_TABLE_NAME); + if (PyErr_Occurred()) { + PyErr_Clear(); + type_pointer = (void *)0; + } +#endif + } + return (swig_module_info *) type_pointer; +} + +#if PY_MAJOR_VERSION < 2 +/* PyModule_AddObject function was introduced in Python 2.0. The following function + is copied out of Python/modsupport.c in python version 2.3.4 */ +SWIGINTERN int +PyModule_AddObject(PyObject *m, char *name, PyObject *o) +{ + PyObject *dict; + if (!PyModule_Check(m)) { + PyErr_SetString(PyExc_TypeError, + "PyModule_AddObject() needs module as first arg"); + return SWIG_ERROR; + } + if (!o) { + PyErr_SetString(PyExc_TypeError, + "PyModule_AddObject() needs non-NULL value"); + return SWIG_ERROR; + } + + dict = PyModule_GetDict(m); + if (dict == NULL) { + /* Internal error -- modules must have a dict! */ + PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__", + PyModule_GetName(m)); + return SWIG_ERROR; + } + if (PyDict_SetItemString(dict, name, o)) + return SWIG_ERROR; + Py_DECREF(o); + return SWIG_OK; +} +#endif + +SWIGRUNTIME void +SWIG_Python_DestroyModule(void *vptr) +{ + swig_module_info *swig_module = (swig_module_info *) vptr; + swig_type_info **types = swig_module->types; + size_t i; + for (i =0; i < swig_module->size; ++i) { + swig_type_info *ty = types[i]; + if (ty->owndata) { + PySwigClientData *data = (PySwigClientData *) ty->clientdata; + if (data) PySwigClientData_Del(data); + } + } + Py_DECREF(SWIG_This()); +} + +SWIGRUNTIME void +SWIG_Python_SetModule(swig_module_info *swig_module) { + static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */ + + PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, + swig_empty_runtime_method_table); + PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule); + if (pointer && module) { + PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); + } else { + Py_XDECREF(pointer); + } +} + +/* The python cached type query */ +SWIGRUNTIME PyObject * +SWIG_Python_TypeCache(void) { + static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); + return cache; +} + +SWIGRUNTIME swig_type_info * +SWIG_Python_TypeQuery(const char *type) +{ + PyObject *cache = SWIG_Python_TypeCache(); + PyObject *key = PyString_FromString(type); + PyObject *obj = PyDict_GetItem(cache, key); + swig_type_info *descriptor; + if (obj) { + descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj); + } else { + swig_module_info *swig_module = SWIG_Python_GetModule(); + descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); + if (descriptor) { + obj = PyCObject_FromVoidPtr(descriptor, NULL); + PyDict_SetItem(cache, key, obj); + Py_DECREF(obj); + } + } + Py_DECREF(key); + return descriptor; +} + +/* + For backward compatibility only +*/ +#define SWIG_POINTER_EXCEPTION 0 +#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) +#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) + +SWIGRUNTIME int +SWIG_Python_AddErrMesg(const char* mesg, int infront) +{ + if (PyErr_Occurred()) { + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + PyErr_Fetch(&type, &value, &traceback); + if (value) { + PyObject *old_str = PyObject_Str(value); + Py_XINCREF(type); + PyErr_Clear(); + if (infront) { + PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str)); + } else { + PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg); + } + Py_DECREF(old_str); + } + return 1; + } else { + return 0; + } +} + +SWIGRUNTIME int +SWIG_Python_ArgFail(int argnum) +{ + if (PyErr_Occurred()) { + /* add information about failing argument */ + char mesg[256]; + PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); + return SWIG_Python_AddErrMesg(mesg, 1); + } else { + return 0; + } +} + +SWIGRUNTIMEINLINE const char * +PySwigObject_GetDesc(PyObject *self) +{ + PySwigObject *v = (PySwigObject *)self; + swig_type_info *ty = v ? v->ty : 0; + return ty ? ty->str : (char*)""; +} + +SWIGRUNTIME void +SWIG_Python_TypeError(const char *type, PyObject *obj) +{ + if (type) { +#if defined(SWIG_COBJECT_TYPES) + if (obj && PySwigObject_Check(obj)) { + const char *otype = (const char *) PySwigObject_GetDesc(obj); + if (otype) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received", + type, otype); + return; + } + } else +#endif + { + const char *otype = (obj ? obj->ob_type->tp_name : 0); + if (otype) { + PyObject *str = PyObject_Str(obj); + const char *cstr = str ? PyString_AsString(str) : 0; + if (cstr) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", + type, otype, cstr); + } else { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", + type, otype); + } + Py_XDECREF(str); + return; + } + } + PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); + } else { + PyErr_Format(PyExc_TypeError, "unexpected type is received"); + } +} + + +/* Convert a pointer value, signal an exception on a type mismatch */ +SWIGRUNTIME void * +SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) { + void *result; + if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { + PyErr_Clear(); + if (flags & SWIG_POINTER_EXCEPTION) { + SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); + SWIG_Python_ArgFail(argnum); + } + } + return result; +} + + +#ifdef __cplusplus +#if 0 +{ /* cc-mode */ +#endif +} +#endif + + + +#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) + +#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else + + + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_p_ARCoordMarcador swig_types[0] +#define SWIGTYPE_p_CoordApuntador swig_types[1] +#define SWIGTYPE_p_Elemento swig_types[2] +#define SWIGTYPE_p_Historico swig_types[3] +#define SWIGTYPE_p_PropiedadesDeteccionApuntador swig_types[4] +#define SWIGTYPE_p_Pui swig_types[5] +#define SWIGTYPE_p_RangosColorApuntador swig_types[6] +#define SWIGTYPE_p_ResultadosCalibracion swig_types[7] +#define SWIGTYPE_p_a_2__double swig_types[8] +#define SWIGTYPE_p_char swig_types[9] +#define SWIGTYPE_p_double swig_types[10] +#define SWIGTYPE_p_int swig_types[11] +#define SWIGTYPE_p_p_char swig_types[12] +#define SWIGTYPE_p_unsigned_char swig_types[13] +static swig_type_info *swig_types[15]; +static swig_module_info swig_module = {swig_types, 14, 0, 0, 0, 0}; +#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) +#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) + +/* -------- TYPES TABLE (END) -------- */ + +#if (PY_VERSION_HEX <= 0x02000000) +# if !defined(SWIG_PYTHON_CLASSIC) +# error "This python version requires swig to be run with the '-classic' option" +# endif +#endif + +/*----------------------------------------------- + @(target):= _PuiModule.so + ------------------------------------------------*/ +#define SWIG_init init_PuiModule + +#define SWIG_name "_PuiModule" + +#define SWIGVERSION 0x010336 +#define SWIG_VERSION SWIGVERSION + + +#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) +#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) + + +#include <stdexcept> + + +namespace swig { + class PyObject_ptr { + protected: + PyObject *_obj; + + public: + PyObject_ptr() :_obj(0) + { + } + + PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj) + { + Py_XINCREF(_obj); + } + + PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj) + { + if (initial_ref) { + Py_XINCREF(_obj); + } + } + + PyObject_ptr & operator=(const PyObject_ptr& item) + { + Py_XINCREF(item._obj); + Py_XDECREF(_obj); + _obj = item._obj; + return *this; + } + + ~PyObject_ptr() + { + Py_XDECREF(_obj); + } + + operator PyObject *() const + { + return _obj; + } + + PyObject *operator->() const + { + return _obj; + } + }; +} + + +namespace swig { + struct PyObject_var : PyObject_ptr { + PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { } + + PyObject_var & operator = (PyObject* obj) + { + Py_XDECREF(_obj); + _obj = obj; + return *this; + } + }; +} + + +#ifndef ESTRUCTURASPUBLICAS_H_ +#define ESTRUCTURASPUBLICAS_H_ + + typedef struct { + int area; + double centro[2]; + double vertex[4][2]; + int visible; + int id; + double cf; + } ARCoordMarcador; + + typedef struct { + int idPatt; + char imagen[255]; + char sonido[255]; + char nombre[255]; + int conjunto; // 0 es conjunto A y 1 es conjunto B + int idElementoRelacionado; // El elemento relacionado debe pertenecer al conjunto opuesto + char nombreRelacion[255]; + int idImagenSDL; + }Elemento; + + typedef struct { + int tope; + int cantHistorico; + int * historicoElementos; + }Historico; + + typedef struct{ + int hmin, hmax, smin, smax,vmin,vmax; + }RangosColorApuntador; + + typedef struct { + int * areas_minimas; //areas_minimas[i] indica el area cota inferior para la deteccion del apuntador sobre el marcador i + int * areas_maximas; //areas_maximas[i] indica el area cota superior para la deteccion del apuntador sobre el marcador i + double * relaciones_promedio; // relaciones_promedio[i] indica la relacion que hay entre el area promedio del apuntador y el area promedio del marcador i + }ResultadosCalibracion; + + + typedef struct { + int area; + double centro[2]; + } CoordApuntador; + +#endif + + + +#include <limits.h> +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + +SWIGINTERN int +SWIG_AsVal_double (PyObject *obj, double *val) +{ + int res = SWIG_TypeError; + if (PyFloat_Check(obj)) { + if (val) *val = PyFloat_AsDouble(obj); + return SWIG_OK; + } else if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else if (PyLong_Check(obj)) { + double v = PyLong_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + double d = PyFloat_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = d; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); + } else { + PyErr_Clear(); + } + } + } +#endif + return res; +} + + +#include <float.h> + + +#include <math.h> + + +SWIGINTERNINLINE int +SWIG_CanCastAsInteger(double *d, double min, double max) { + double x = *d; + if ((min <= x && x <= max)) { + double fx = floor(x); + double cx = ceil(x); + double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + if ((errno == EDOM) || (errno == ERANGE)) { + errno = 0; + } else { + double summ, reps, diff; + if (rd < x) { + diff = x - rd; + } else if (rd > x) { + diff = rd - x; + } else { + return 1; + } + summ = rd + x; + reps = diff/summ; + if (reps < 8*DBL_EPSILON) { + *d = rd; + return 1; + } + } + } + return 0; +} + + +SWIGINTERN int +SWIG_AsVal_long (PyObject *obj, long* val) +{ + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + long v = PyInt_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { + if (val) *val = (long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_int (PyObject * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< int >(v); + } + } + return res; +} + + + #define SWIG_From_long PyInt_FromLong + + +SWIGINTERNINLINE PyObject * +SWIG_From_int (int value) +{ + return SWIG_From_long (value); +} + + + #define SWIG_From_double PyFloat_FromDouble + + +SWIGINTERN swig_type_info* +SWIG_pchar_descriptor(void) +{ + static int init = 0; + static swig_type_info* info = 0; + if (!init) { + info = SWIG_TypeQuery("_p_char"); + init = 1; + } + return info; +} + + +SWIGINTERN int +SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) +{ + if (PyString_Check(obj)) { + char *cstr; Py_ssize_t len; + PyString_AsStringAndSize(obj, &cstr, &len); + if (cptr) { + if (alloc) { + /* + In python the user should not be able to modify the inner + string representation. To warranty that, if you define + SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string + buffer is always returned. + + The default behavior is just to return the pointer value, + so, be careful. + */ +#if defined(SWIG_PYTHON_SAFE_CSTRINGS) + if (*alloc != SWIG_OLDOBJ) +#else + if (*alloc == SWIG_NEWOBJ) +#endif + { + *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1))); + *alloc = SWIG_NEWOBJ; + } + else { + *cptr = cstr; + *alloc = SWIG_OLDOBJ; + } + } else { + *cptr = PyString_AsString(obj); + } + } + if (psize) *psize = len + 1; + return SWIG_OK; + } else { + swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); + if (pchar_descriptor) { + void* vptr = 0; + if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) { + if (cptr) *cptr = (char *) vptr; + if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0; + if (alloc) *alloc = SWIG_OLDOBJ; + return SWIG_OK; + } + } + } + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsCharArray(PyObject * obj, char *val, size_t size) +{ + char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ; + int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc); + if (SWIG_IsOK(res)) { + if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize; + if (csize <= size) { + if (val) { + if (csize) memcpy(val, cptr, csize*sizeof(char)); + if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char)); + } + if (alloc == SWIG_NEWOBJ) { + delete[] cptr; + res = SWIG_DelNewMask(res); + } + return res; + } + if (alloc == SWIG_NEWOBJ) delete[] cptr; + } + return SWIG_TypeError; +} + + +SWIGINTERNINLINE PyObject * +SWIG_FromCharPtrAndSize(const char* carray, size_t size) +{ + if (carray) { + if (size > INT_MAX) { + swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); + return pchar_descriptor ? + SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void(); + } else { + return PyString_FromStringAndSize(carray, static_cast< int >(size)); + } + } else { + return SWIG_Py_Void(); + } +} + + + +#include <numpy/arrayobject.h> +/*Incluyo Artoolkit*/ +#include <AR/param.h> +#include <AR/ar.h> +#include <AR/arMulti.h> +#include <AR/video.h> + +#include <sys/ioctl.h> +#include <linux/videodev.h> +#include <fcntl.h> + + + + +#define FORMA_APUNTADOR_CIRCULO 1 +#define FORMA_APUNTADOR_RECTANGULAR 2 +#define FORMA_APUNTADOR_MANO 3 + +#define ERROR_DETECTANDO_MARCADORES 4 +#define ERROR_CALCULANDO_MATRIZ_TRANSFORMACION 5 +#define ERROR_NINGUN_MARCADOR_DETECTADO 6 +#define ERROR_IMAGEN_NULL 7 +#define DETECCION_CORRECTA 8 + +#define MASCARA_APLICADA 9 +#define MASCARA_NO_APLICADA 10 + +#define TIPO_MASCARA_BINARIA 11 +#define TIPO_MASCARA_ATENUANTE 12 + +#define ERROR_TOMAR_MUESTRA_FORMA_NO_IMPLEMENTADA 13 +#define ERROR_TOMAR_MUESTRA_OK 14 + +#define OFFSET_ROI 5 //Cuanto mas grande mas grande sera el ROI donde busco el apuntador +#define MIN_AREA_WIDTH_HEIGHT 5 //Este valor sirve para indicar cual es el area minima en la cual se busca un apuntador. + //Por ejemplo si el marcador se encuentra apenas dentro de la pantalla y el height o el width no superan este valor entonces + //el area no sera analizada en busca de un apuntador + +#define MIN_CF_MARKER_DETECT 0.6 +#define MODO_MULTI_MARKERS 15 +#define MODO_SIMPLE 16 +#define MODO_MULTI_MARKERS_CALIBRADOR 17 + +#include "cvUtilities.h" +#include "Estructuras.h" +#include "Funciones.h" +#include "Estructuras_wrapp.h" + +class Pui { + +public: + + static int const FAST_SPEED_LOOP = 15; + static int const NORMAL_SPEED_LOOP = 16; + static double const FAST_SPEED_LOOP_MULTIPLIER = 1./8.; + static double const NORMAL_SPEED_LOOP_MULTIPLIER = 1./2.; + + int insert(unsigned char *bytes, int len); + binary_data out(); + + + Pui(); + virtual ~Pui(); + + /************************************** Manejo de Objetos PUI **************************************/ + /* + * Inicializa los objetos PUI desde un archivo de texto. + * Como máximo se cargan la cantidad indicada por max_elementos + * + * Además de las propiedades de cada objeto PUI también se carga un sonido + * de error y uno de éxito + * + * @param archivoConfiguracion Ruta completa del archivo de configuración + * @param max_elementos Candidad máxima de elementos que serán cargados + */ + int leerConfiguracionObjetosPUI(const char* archivoConfiguracion,int max_elementos); + + /** + * Lee un archivo de configuracion conteniendo una lista de ruta de archivos .patt + * que seran cargados para utilizar en el modo MODO_SIMPLE + * + * @param config_name Ruta completa del archivo conteniendo la lista de .patt + * + * @return Retorna la cantidad de marcadores que fueron cargados + */ + int leerPatternsModoSimple(const char* config_name); + /** + * Imprime en consola la información de los objetos PUI cargados + */ + void imprimirPropiedadesObjetosPUI(); + + + /*Funciones para acceder a propiedades de los objetos PUI*/ + + /** + * Retorna el nombre del Objeto PUI correspondiente al identificador idObjeto + * + * @param idObjeto Identificador del Objeto PUI + */ + char * getNombreObjetoPUI(int idObjeto); + + /** + * Retorna la ruta del archivo de sonido asociado al Objeto PUI correspondiente al identificador idObjeto + * + * @param idObjeto Identificador del Objeto PUI + */ + char * getSonidoObjetoPUI(int idObjeto); + + /** + * Retorna la ruta del archivo de imagen asociado al Objeto PUI correspondiente al identificador idObjeto + * + * @param idObjeto Identificador del Objeto PUI + */ + char * getImagenObjetoPUI(int idObjeto); + + /** + * Retorna la ruta del archivo de sonido de error. + */ + char* getSonidoError(); + + /** + * Retorna la ruta del archivo de sonido de exito. + */ + char* getSonidoOk(); + + /** + * Retorna true si y solo si el objeto1 esta relacionado con el objeto2 + * objeto1---->objeto2 + * No tiene porque cumplirse la coondicion inversa ( objeto2--->objeto1) + */ + bool esRelacionCorrecta(int idObjeto1,int idObjeto2); + + int getConjuntoObjetoPui(int idObjeto); + + int getIdElementoRelacionado(int idObjeto); + + char * getNombreRelacionObjetoPUI(int idObjeto); + + /* Si hay algun apuntador tocando un marcador entonces devuelve el indice del marcador, + * de lo contrario retorna -1. Como máximo retorna el id de un sólo marcador aunque + * puedan existir multiples selecciones + * + * Algoritmo de detección: + * + * 1- Para cada marcador M no detectado: + * 1.1 - hay apuntador en el área correspondiente a M? + * 1.1.1 - Si ==> MarcadorSeleccionado = M + * break //termina el loop + * + * 2- Está habilitada la funciónalidad de historico? + * 2.1 - cantDeteccionesMarcador = Registrar detección (M) + * 2.2 - cantDeteccionesMarcador >= CANT_HISTORICO? + * 2.1 - Si ==> retorno M.id + * 2.2 - No ==> retonro -1 (aun no se llegó a detectar la selección sobre el mismo marcador la cantidad mÃnima + * de veces seguidas para decidir que realmente se haya producido una selección. Esta funcionalidad + * se denomina histórico y agrega robustez al algoritmo de detección evitando falsos positivos en + * los casos en que el apuntador no se detenga encima del marcador o que simplemente se haya introducido + * ruido en la imágen) + * + * Desarrollo del punto 1.1: + * Función hayApuntador: + * 1- Transformar la imagen original img a su respectiva representación en HSV(H:0-360,S:0-100,V:0-100) : img_hsv + * 2- Binarización de la imágen: + * 2.1: Para cada pÃxel P perteneciente a img_hsv: + * 2.1.1 : P está dentro de los rangos de color (definidos en la estructura RangosColorApuntador) ? + * 2.1.1.1 Si ==> img_mono[indice(P)] = 1 + * 2.1.1.2 No ==> img_mono[indice(P)] = 0 + * + * 3 - Aplicar cvSmooth (openCV) para eliminar ruido + * Si PropiedadesDeteccionApuntador.smooth El smooth o también conocido como blur (desenfoque) genera un borroneo en la + * ==> img_mono = cvSmooth(img_mono) imagen y se utiliza para reducir el ruido de la imagen. Se utiliza un vecindario de 7x7 pÃxeles para este filtro + * ------------------------------------------------------ + * 4 - Aplicar cvErode (openCV) para eliminar ruido. + * Si PropiedadesDeteccionApuntador.erode > 0 Esta operación se utiliza para eliminar las pequeñas manchas aisladas en + * ==> img_mono = cvErode(img_mono,PropiedadesDeteccionApuntador.erode) la imagen. La idea es que las pequeñas manchas desaparezcan pero que + * las áreas mas grandes y significativas queden visibles. Luego de aplicar + * este filtro deberÃan permanecer en la imágen binaria solamente aquellos + * objetos de tamaño significativo cuyo color estaba comprendido dentro de los + * rangos aplicados en la binarización. + * ------------------------------------------------------ + * 5- Aplicar cvDilate (openCV). + * Si PropiedadesDeteccionApuntador.dilate > 0 Se aplica dilate para conectar regiones cercanas y asi encontrar componentes + * ==>img_mono = cvDilate(img_mono,PropiedadesDeteccionApuntador.dilate) conectados. Muchas veces algunas regiones quedan con vacios que pueden ser producidos + * por ejemplo por un punto de luz u otro tipo de ruido. Una pequeña dilatación alrededor + * de estas regiones vacias puede terminar rellenandolas y produciendo un componente conexo sin + * agujeros. (luego se aproximan los componentes a polÃgonos y se hayan sus contornos) + * 6- Deteccion de contornos y calculo del area + * 6.1- contornos = calcularContonosExteriores(img_mono) Calcula solamente los contornos exteriores, no interesan aquellos contornos que estén anidados + * Si: PropiedadesDeteccionApuntador.enclosing_circle + * ==> area = area del circulo que circunscribe al contorno -- Se utiliza cvMinEnclosingCircle + * No: + * ==> area = area de la aproximacion por poligono del contorno -- Se utiliza poly = cvApproxPoly y area = cvContourArea(poly) + * 6.2 (area>=PropiedadesDeteccionApuntador.min_area && + * area<=(areaMarcador/PropiedadesDeteccionApuntador.factorProporcionApuntadorMarcador))? --Actualmente los chequeos de proporcion entre el area del + * Si:==>retorna area apuntador y el marcador no son de mucha utilidad porque no se + * No:==>retorna -1 logró una precisión tan exacta en los calculos de ambas áreas y + * los resultados son muy variables. + * En cambio es importante establecer un area minima y chequear que el + * area encontrada al menos la iguale, esto evita falsos positivos por ruido + * en la imagen u objetos con tonalidades similares al apuntador + * + * + * + * */ + int detectarSeleccion(); + + /** + * Se inicializan los parámetros para realizar la detección de los marcadores. + * También se inicializan las estructuras e imágenes auxiliares que se utilizan para la detección del apuntador. + * + * @param propiedadesDeteccion estructura con las propiedades utilizadas para realizar la detección del apuntador. + * Ver documentación de la estructura PropiedadesDeteccionApuntador y de la función Pui::detectarSeleccion + * + * @param rangosColorApuntador estructura que indica el rango de colores en representación HSV utilizado para la + * detección del apuntador + * Ver documentación de la estructura RangosColorApuntador y de la función Pui::detectarSeleccion + */ + void initDeteccionApuntador(PropiedadesDeteccionApuntador propiedadesDeteccion,RangosColorApuntador rangosColorApuntador); + + /** + * Se inicializan los parámetros para realizar la detección de los marcadores a partir de un archivo de configuración + * También se inicializan las estructuras e imágenes auxiliares que se utilizan para la detección del apuntador. + + * Ver documentación de archivos de configuración + */ + int initDeteccionApuntador(char* configuracionFileName); + + /** + * Devuelve la configuración utilizada para la deteccion del apuntador. + * area minima + * proporcion entre el area del apuntador y los marcadores + * Parámetros para la eliminación de ruido: erode, dilate y smooth + * Flag indicando si el algorimo de detección aproxima el contorno del apuntador y + * por lo tanto su área a la de un cÃrculo + */ + PropiedadesDeteccionApuntador getPropiedadesDeteccionApuntador(); + + /** + * Establece la configuración utilizada para la deteccion del apuntador. + * + * propiedadesDeteccion.min_area : area minima + * propiedadesDeteccion.factorProporcionApuntadorMarcador : proporcion entre el area del apuntador y los marcadores + * propiedadesDeteccion.erode/dilate/smooth : Parámetros para la eliminación de ruido: erode, dilate y smooth (1,1,1 en casos normales) + * propiedadesDeteccion.enclosing_circle: Flag indicando si el algorimo de detección aproxima el contorno del apuntador y + * por lo tanto su área a la de un cÃrculo. Se recomienda setearla en 1 cuando se utilizan apuntadores + * con forma aproximada a una esfera + */ + void setPropiedadesDeteccionApuntador(PropiedadesDeteccionApuntador propiedadesDeteccion); + + /** + * Devuelve los rangos HSV en los que se está intentando detectar el apuntador. + * La escala HSV utilizada en todos los casos es : H:0-360 S:0-100 V:0-100 + */ + RangosColorApuntador getPropiedadesColorApuntador(); + + /** + * Establece los rangos HSV en los que se está intentando detectar el apuntador. + * La escala HSV utilizada en todos los casos es : H:0-360 S:0-100 V:0-100 + */ + void setPropiedadesColorApuntador(RangosColorApuntador rangosColorApuntador); + + /** + * Establece solamente el Hue minimo para la binarización de + * la imagen en el algoritmo de detección del apuntador. (Setea RangosColorApuntador.hmin) + */ + void setHminApuntador(int hMin); + /** + * Devuelve el Hue minimo para la binarización de + * la imagen en el algoritmo de detección del apuntador. (Retorna RangosColorApuntador.hmin) + */ + int getHminApuntador(); + + /** + * Establece solamente el Hue maximo para la binarización de + * la imagen en el algoritmo de detección del apuntador. (Setea RangosColorApuntador.hmax) + */ + void setHmaxApuntador(int hMax); + + /** + * Devuelve el Hue maximo para la binarización de + * la imagen en el algoritmo de detección del apuntador. (Retorna RangosColorApuntador.hmax) + */ + int getHmaxApuntador(); + + /*Análoga a setHmin*/ + void setSminApuntador(int vMin); + + /*Análoga a getHmin*/ + int getSminApuntador(); + + /*Analoga a setHmax*/ + void setSmaxApuntador(int vMax); + + /*Análoga a getHmax*/ + int getSmaxApuntador(); + + /*Analoga a setHmin*/ + void setVminApuntador(int vMin); + + /*Análoga a getHmin*/ + int getVminApuntador(); + + /*Analoga a setHmax*/ + void setVmaxApuntador(int vMax); + + /*Análoga a getHmax*/ + int getVmaxApuntador(); + + /***************************************************************************************************/ + + + /*************************** Calibracion de Proporcion apuntador-marcador ***********************/ + + /** + * Calcula los resultados de la calibración que establece la proporción + * del área del apuntador y el marcador. + * + * Actualmente obsoleta, para que funcione de forma óptima la comparación del área entre el + * marcador y el apuntador se requiere mayor precisión en los algoritmos que calculan ambas áreas. + * + * Para mayor información ver el programa Calibrador adjunto con la distribución PUI + */ + void procesarDatosCalibracion(); + + /** + * Guarda los resultados de la calibración que establece la proporción + * del área del apuntador y el marcador. + * + * Actualmente obsoleta, para que funcione de forma óptima la comparación del área entre el + * marcador y el apuntador se requiere mayor precisión en los algoritmos que calculan ambas áreas. + * + * @param nombreArchivo Ruta completa del archivo donde se guarda la configuración + */ + void guardarDatosCalibracion(const char* nombreArchivo); + + + /** + * Inicializa las propiedades para el calibrador de la proporcion de las areas del apuntador + * y los marcadores + * + * Actualmente obsoleta, se necesita migrar mas funcionalidades a la clase Pui para + * que soporte este tipo de calibracion + */ + void initPropiedadesCalibracion(int veces_por_marcador, int cant_marcadores, int metodo,int debug); + + /** + * Inicializa las imagenes que se utilizan en el calibrador de la proporcion de las areas del apuntador + * y los marcadores + * + * Actualmente obsoleta, se necesita migrar mas funcionalidades a la clase Pui para + * que soporte este tipo de calibracion + */ + int leerConfiguracionCalibracion(const char* archivoConfiguracion, int cantMarcadores, char** imagenes); + + /***************************************************************************************************/ + + + + /*********************************** Calibracion Threshold ARToolkit **************************************/ + + /** + * Calcula el Threshold utilizado por artoolkit (por mas info ver documentación de Artoolkit) que + * mejor funciona con los marcadores que se esten utilizando. + * + * La definición de que un valor t1 de threshold es mejor que otro valor t2 está dada por: + * t1 detecta mas marcadores que t2? + * Si: ==> t1 es mejor + * No: ==> detectan la misma cantidad de marcadores? (luego de cantidad_iteraciones se realiza un + * promedio de marcadores detectados) + * Si: Si el promedio de CF (valor de confianza de que un marcador detectado realmente sea ese marcador, ver + * documentacion de Artoolkit) para todos los marcadores utilizando t1 es mayor al + * de t2 ==> t1 es mejor, sino t2 es mejor. + * No: Entonces t2 detecta mas marcadores, por lo tanto t2 es mejor. + * + * En resumen, t1 es mejor que t2 si detecta mas marcadores, en caso de empate se decide cual es mejor + * comprando los promedios de CF obtenidos + * + * El valor calculado se almacena en Pui.dataArtoolkit.thresh + * + * @param cantidad_iteraciones Cantidad de veces que se detectan los marcadores + */ + void calibrarThreshold(int cantidad_iteraciones); + + /***************************************************************************************************/ + + + + + /**************************************** Propiedades y manejo de video ************************************/ + /* El dispositivo utilizado debe permitir estas opciones, de lo contrario el resultado es impredecible*/ + + /** + * Setea el brillo + */ + void setBrillo(int brillo, char * device); + + /** + * Setea en true o false el Balance de blanco automatico + */ + void setAutoWhiteBalance(int habilitado,char * device); + + /** + * Setea en true o false el AGC (Auto Gain Control) + */ + void setAutoGain(int habilitado,char * device); + + /** + * Setea flip horizontal en la imagen de video + */ + void setHorizontalFlip(int habilitado,char * device); + + /** + * Abre una ventana para desplegar el video. + * Pui debe ser compilado con la bandera GLUT_HABILITADO , de lo contrario no hace nada + */ + void abrirVentanaGrafica(); + + /** + * Cierra la ventana abierta mediante la funcion Pui::abrirVentanaGrafica + * Invocar esta funcion al finalizar el programa + * Pui debe ser compilado con la bandera GLUT_HABILITADO , de lo contrario no hace nada + */ + void cerrarVentanaGrafica(); + + /** + * Despliega video en la ventana abierta por la funcion Pui::abrirVentanaGrafica() + * Pui debe ser compilado con la bandera GLUT_HABILITADO , de lo contrario no hace nada + * + * @param debug Indica si se debe mostrar la imagen en modo debug. + */ + void desplegarImagenAR(bool debug); + + /** + * Despliega video en la ventana abierta por la funcion Pui::abrirVentanaGrafica() + * Pui debe ser compilado con la opcion GLUT_HABILITADO , de lo contrario no hace nada + */ + void desplegarImagenFromData(unsigned char * imageData); + + /** + * Capturar siguiente Frame + * + * Actualmente obsoleta, en la implementacion de Artoolkit (video.c) para captura de video esta + * funcion no hace nada y siempre retorna TRUE + */ + void capNext(); + + /** + * Comienza la captura de video + */ + void capStart(); + + /** + * Detiene la captura de video + */ + void capStop(); + + /** + * Finaliza la captura de video. + * Previo se debe llamar a capStop + */ + void capClose(); + /***************************************************************************************************/ + + + /*********************************** Captura de video *********************************/ + + /** + * Si hay un frame disponible entonces lo retorna. + * De lo contrario duerme y retorna NULL + */ + unsigned char* capturarImagenAR(); + + /** + * Si hay un frame disponible entonces lo retorna. + * De lo contrario duerme y retorna NULL + * + * Solamente para pasaje de unsigned char* a Python mediante el + * typemap de binary_data. Ver archivo Pui.i + */ + binary_data capturarPyImageAR(); + + /** + * Retorna la imagen de debug utilizada por artoolkit. + * No se debe trabajar sobre esta imagen. Es de uso interno + * de artoolkit. + * + * Es recomendable hacer una copia de los datos antes de realizar + * cualquier modificacion + */ + unsigned char* obtenerImagenDebugAR(); + + //TODO Incluir la funcionalidad que retorna la imagen de debug para Python + //Implementacion analoga a capturarPyImageAR + //binary_data* obtenerPyImagenDebugAR(); + + + /*******************************************************************************************/ + + + /******************************** Calibracion de color el apuntador ********************************/ + + /* + * Inicializa los histogramas en cero + * Inicializa los resultados en los rangos maximos (H:0-360,S:0-100,V:0-100) + * Registra la forma de la mascara que se aplica a los frames obtenidos de la camara (circulo, rectangulo, mano) + * Actualmente solo soporta FORMA_APUNTADOR_CIRCULO + * + * @param forma Los posibles valores son FORMA_APUNTADOR_CIRCULO, FORMA_APUNTADOR_MANO y FORMA_APUNTADOR_RECTANGULAR. + * Actualmente solo funciona con FORMA_APUNTADOR_CIRCULO. + * + * @param rangos_escala Rangos de la escala HSV que se utilizara. Se recomienda excluir los valores 0 en H para evitar que se introduzca ruido + * por el negro y blanco de los marcadores. Utilizar Hmin=1 y Hmax=360 + * + * @param h_bins Cantidad de Intervalos utilizados en el histograma calculado para H. Valor recomendado = 30 + * + * @param s_bins Cantidad de Intervalos utilizados en el histograma calculado para S. Valor recomendado = 20 + * + * @param v_bins Cantidad de Intervalos utilizados en el histograma calculado para V. Valor recomendado = 20 + * */ + void initPropiedadesCalibracionSoloApuntador(int forma,RangosColorApuntador rangos_escala,int h_bins, int s_bins, int v_bins,int debug); + + + /* + * Inicializa los histogramas en cero + * Inicializa los resultados en los rangos maximos (H:0-360,S:0-100,V:0-100) + * Registra la forma de la mascara que se aplica a los frames obtenidos de la camara (circulo, rectangulo, mano) + * Actualmente solo soporta FORMA_APUNTADOR_CIRCULO + * + * @param forma Los posibles valores son FORMA_APUNTADOR_CIRCULO, FORMA_APUNTADOR_MANO y FORMA_APUNTADOR_RECTANGULAR. + * Actualmente solo funciona con FORMA_APUNTADOR_CIRCULO. + * + * @param rangos_escala Rangos de la escala HSV que se utilizara. Se recomienda excluir los valores 0 en H para evitar que se introduzca ruido + * por el negro y blanco de los marcadores. Utilizar Hmin=1 y Hmax=360 + * + * @param h_bins Cantidad de Intervalos utilizados en el histograma calculado para H. Valor recomendado = 30 + * + * @param s_bins Cantidad de Intervalos utilizados en el histograma calculado para S. Valor recomendado = 20 + * + * @param v_bins Cantidad de Intervalos utilizados en el histograma calculado para V. Valor recomendado = 20 + * */ + void initPropiedadesCalibracionSoloApuntador(int forma,int hmin,int hmax, int smin, int smax, int vmin, int vmax,int h_bins, int s_bins, int v_bins,int debug ); + + + /* + * A partir de los marcadores detectados selecciona uno y aplica la mascara segun la forma seleccionada + * Como resultado se deja el frame con la mascara aplicada (this->dataArtoolkit.dataPtr) + * En caso de exito retorna TIPO_MASCARA_BINARIA, de lo contrario retorna MASCARA_NO_APLICADA + * + * @param idMarcador Se aplica la mascara dejando visible el marcador indicado + * @param tipoMascara Los posibles valores son TIPO_MASCARA_ATENUANTE y TIPO_MASCARA_BINARIA + */ + int aplicarNuevaMascaraCalibrador(int idMarcador,int tipoMascara); + + /*Solamente aplica una mascara previamente calculada por la funcion aplicarNuevaMascaraCalibrador + * si antes no se llama al menos una vez a aplicarNuevaMascaraCalibrador entonces no se aplicara la mascara + * En caso de exito retorna TIPO_MASCARA_BINARIA, de lo contrario retorna MASCARA_NO_APLICADA + * + * @param tipoMascara Los posibles valores son TIPO_MASCARA_ATENUANTE y TIPO_MASCARA_BINARIA + * */ + int aplicarMascaraCalibrador(int tipoMascara); + + /** + * Las mascaras para el tipo de apuntador FORMA_APUNTADOR_CIRCULO son circunferencias aproximadamente + * del tamaño del marcador. + * + * Esta operacion permite achicar o agrandar la circunferencia + * + * @param restarAlRadio Los valores positivos achican la circunferencia, los valores negativos la agrandan + */ + void setAchicarRadioMascaraCircular(int restarAlRadio); + + /** + * Devuelve el valor que se esta restando al radio de la circunferencia usada + * en la calibracion de apuntadores de tipo FORMA_APUNTADOR_CIRCULO. + * + * Inicialmente siempre es 0 + */ + int getAchicarRadioMascaraCircular(); + + /** + * Retorna imagen usada en la calibracion. + * Puede ser util para debaguear + */ + unsigned char* getCalibrationImage(); + + //TODO Incluir la funcionalidad que retorna la imagen de debug para Python + //binary_data getCalibrationImage(); + + /*Calcula el histograma filtrado por la mascara lo acumula al histograma calculado con las muestras anteriores*/ + int tomarMuestraApuntador(); + + /** + * Calcula los resultados de la calibracion del color del apuntador. + * + * @param factorThreshH Indica que nivel debe superar intervalo de H para ser incluido en los resultados. + * Valores alto producen una calibracion de H menos exigente y mas amplia, valores muy pequeños + * producen una calibracion muy precisa y puntual. + * Si el maximo en el histograma H se da con un valor de N pixeles (por ejemplo N pixeles que + * caen en el rango 20-50 del histograma H) entonces todos los intervalos (hay hbins intervalos en el hist H) + * que tengan un valor menor a N/H seran considerados nulos. + * Valor Recomendado = 10. En caso de que la calibracion falle porque los histogramas queden discontinuos + * (cuando esta funcion devuelve ERROR_RANGOS_HISTOGRAMA_NO_CONTINUO) se recomienda probar con valores mas altos + * de factorThreshH. + * En caso que la calibracion genere posteriores falsos positivos en la deteccion del apuntador se recomienda + * disminuir este valor. + * + * @param minPorcentajeRuido Indica el porcentaje de muestras para los intervalos de S y V que se consideran ruido y son puestos en 0. + * En caso de que un intervalo de S o V tenga menos pixeles que minPorcentajeRuido % sera puesto en 0. + * Ejemplo . Intervalo Saturation[0-30] = 1000 px. En un total de 320*240=76800, 20px corresponde a un 1,3% del total, + * si minPorcentajeRuido=3 entonces el intervalo Saturation[0-30] se pone en 0 y no se incluye en los resultados + * Valor Recomendado = 3 + * En caso que la calibracion genere posteriores falsos positivos en la deteccion del apuntador se recomienda + * aumentar este valor. + * + */ + int calcularResultadosCalibracionApuntador(int factorThreshH,int minPorcentajeRuido); + + /** + * Guarda solamente los rangos HSV calculados para el apuntador. + * + * @param nombreArchivo Ruta completa del archivo donde se guardar los resultados + */ + void guardarSoloRangosColorApuntador(char * nombreArchivo); + + /** + * Guarda los rangos HSV calculados y ademas los valores pasados por parametro. + * + * @param area_min (Recomendado 300, lo mas recomendable es probar segun el apuntador que se este usando. + * Valores muy pequeños producen falsos positivos en la deteccion) + * @param erode (ver documentacion de Pui::detectarSeleccion(). Valor recomendado = 1) + * @param dilate (ver documentacion de Pui::detectarSeleccion(). Valor recomendado = 1) + * @param smooth (ver documentacion de Pui::detectarSeleccion(). Valor recomendado = 1) + * @param usarEnclosingCircle (ver documentacion de Pui::detectarSeleccion(). Valor recomendado = 1 para apuntadores esfericos, 0 en otros casos) + * * @param nombreArchivo Ruta completa del archivo donde se guardar los resultados + */ + void guardarCalibracionApuntador(char * nombreArchivo,int area_min,float factorProporcionUnico,int erode, int dilate,int smooth,int usarEnclosingCircle); + + /* + * Setea la propiedad debug_imagenes en las props del calibrador + */ + void setDebugCalibracion(bool debug); + + /** + * Devuelve true si se esta en modo debug mientras se realiza la calibracion del apuntador + */ + bool isDebugCalibracion(); + + /* + * Retorna los resultados de la calibracion del color del apuntador o + * los rangos que se esten usando actualmente (seteados manualmente o cargados desde un archivo de configuracion) + * + * */ + RangosColorApuntador getResultadosRangosColor(); + + /******************************************************************************************************************/ + + + + /******************************************* Manejo de ARToolkit **************************************************/ + + + /*Devuelve la informacion de todos los marcadores + * Tanto los marcadores que no figuran en la estructura de dectados pero estan como visible o aquellos + * que directamente estan como no visibles tendran su area y cf en -1 */ + int detectarYCalcularPosicionTodosMultiMarkers(); + + /** + * En caso de que Pui.modo sea MODO_MULTI_MARKERS invoca a la funcion detectarYCalcularPosicionTodosMultiMarkers + * si Pui.modo es MODO_SIMPLE invoca a la funcion detectarMarcadoresSimple + */ + int detectarMarcadores(); + + /** + * Detecta un marcador cargado en modo MODO_SIMPLE. + * Se guarda el id del marcador detectado y puede ser consultado mediante + * la funcion Pui::getMarcadorSimpleDetectado + * Si se detecta mas de un marcador se guarda el id del marcador con mayor nivel + * de confianza (cf) detectado, es decir el que se haya detectado con mayor seguridad + */ + int detectarMarcadoresSimple(); + + /** + * Retorna el id del marcador y objeto PUI detectado en la ultima invocacion + * a la funcion Pui::detectarMarcadoresSimple + */ + int getIdMarcadorSimpleDetectado(); + + /** + * Retorna la informacion correspondiente al marcador detectado en la ultima invocacion + * a la funcion Pui::detectarMarcadoresSimple. + * El id del marcador es el mismo que el id del objeto PUI asociado. + */ + ARCoordMarcador getMarcadorSimpleDetectado(); + + + /** + * Retorna la información contenida en la estructura ARCoordMarcador para el marcador de id idMarcador + * Solo se utiliza en el caso de modo MODO_MULTI_MARKERS. + * Siempre se dispone de cada propiedad de la estructura ARCoordMarcador aunque el marcador no + * haya sido detectado (su area, coordenadas y verticas son calculados a partir de la informacion + * de aquellos marcadores detectados ) a excepcion de la propiedad cf que no tiene sentido en caso + * de que el marcador no haya sido detectado. + * + * @param idMarcador Identificador del marcador + */ + ARCoordMarcador getInfoMultiMarcador(int idMarcador); + + /** + * Utilizada en el modo MODO_SIMPLE + * Establece el minimo nivel de confianza para la deteccion de un marcador. + * Al detectar un marcador Artoolkit devuelve un valor llamado cf (entre 0 y 1) el cual indica + * la seguridad que se tiene de que el marcador detectado realmente sea ese + */ + void setARCf(double cf); + + /** + * Devuelve el nivel de confianza establecido para la deteccion de marcadores + * en el modo MODO_SIMPLE + */ + double getARCf(); + /** + * Setea el umbral de binarizacion usado por artoolkit. + * En condiciones de poca luz usar valores bajos. + * Valor por defecto = 100 + */ + int getARThreshold(); + + /** + * Setea el umbral de binarizacion usado por artoolkit. + * En condiciones de poca luz usar valores bajos. + */ + void setARThreshold(int threshold); + + /**************************************************************************************************************************************/ + + + + + + + + + + + + + + + + + + + /****************************************GENERALES PUI**********************************************************/ + + /** + * Inicialización de PUI con soporte para capturar video + * + * @param modo Indica el modo de operación, las posibilidades son: + * 1. MODO_SIMPLE : No trabaja con multiples marcadores relacionados, simplemente se detectan los marcadores que + * se definieron en el archivo de configuración de objetos PUI y no soporta el uso de apuntadores. + * Si un marcador no es detectado entonces sus coordenadas no podrán ser calculadas a partir de las + * coordenadas de los demas marcadores (no existe relacion alguna entre ellos). + * Cuando se inicializa PUI en este modo debe utilizarse la funcion Pui::detectarMarcadoresSimples + * o Pui::detectarMarcadores la cual pregunta por el modo de operacion y realiza la correspondiente + * invocacion a Pui::detectarMarcadoresSimples o Pui::detectarYCalcularPosicionTodosMultiMarkers segun corresponda. + * + * 2. MODO_MULTI_MARKER : Trabaja con marcadores relacionados entre ellos. La posición de cada marcador es relativa a la de los + * demas. Por lo tanto, detectando por lo menos un marcador es capaz de deducir la posición en pantalla del + * resto. + * Este modo se utiliza junto con apuntadores que al tapar un marcador disparan la selección del correspondiente + * marcador. + * Cuando se inicializa PUI en este modo debe utilizarse la funcion Pui::detectarMarcadoresSimples + * o Pui::detectarMarcadores la cual pregunta por el modo de operacion y realiza la correspondiente + * invocacion a Pui::detectarMarcadoresSimples o Pui::detectarYCalcularPosicionTodosMultiMarkers segun corresponda. + * + * @param propiedadesDeteccion Parametros para la detección del apuntador en caso que se utilice MODO_MULTI_MARKER + * Ver documentacion de la funcion Pui::setPropiedadesDeteccionApuntador + * + * @param rangosColorApuntador Parametros que definen el rango de colores HSV en los cuales se busca el apuntador + * Ver documentacion de la funcion Pui::setPropiedadesColorApuntador + * + * + * @param configMarcadoresAR Si modo = Pui.MODO_MULTI_MARKER + * ==> Ruta completa del archivo de configuracion de Artoolkit que relaciona la posicion de los marcadores. + * Solamente soportado para el modo MODO_MULTI_MARKER + * Para mas informacion ver http://www.hitl.washington.edu/artoolkit/documentation/tutorialmulti.htm + * + * Si modo = Pui.MODO_SIMPLE + * ==> Ruta completa del archivo de configuracion donde se definen los marcadores que se van a utilizar + * Este archivo consiste en un conjunto de rutas que apuntan a los .patt correspondientes a cada marcador. + * El orden en que se declaran los archivos .patt debe ser el mismo orden en el que se declaran los objetos PUI + * cargados por la funcion Pui::leerConfiguracionObjetosPUI + * + * @param camera_para Archivo de calibracion de la camara + * + * @param vconf String de configuracion para gstreamer. En caso de ser vacio se utiliza el valor de la variable de ambiente ARTOOLKIT_CONFIG + * + * @param usarAlgoritmoRapido Utiliza los algoritmos Lite de artoolkit para la deteccion de marcadores. Esto supone un tiemp de procesamiento menor + * pero tambien una menor precision de la deteccion de los marcadores. En hardware con alto poder computacional no hay + * motivo para utilizar este tipo de algoritmo Lite. + * + * @param loopSpeed Posibles valores: Pui.FAST_SPEED_LOOP y Pui.NORMAL_SPEED_LOOP. Ver documentacion de estas dos constantes + * + * @param zoom En caso de haber compilado PUI con soporte para desplegar video (bandera GLUT_HABILITADO) entonces este + * parametro indica el zoom para desplegar video. + */ + void initPuiConCapturaDeVideo(int modo,PropiedadesDeteccionApuntador propiedadesDeteccion,RangosColorApuntador rangosColorApuntador, + char * configMarcadoresAR,char * camera_para,char *vconf,int usarAlgoritmoRapido,int loopSpeed,double zoom); + + + /** + * Inicialización de PUI con soporte para capturar video + * + * @param modo Indica el modo de operación, las posibilidades son: + * 1. MODO_SIMPLE : No trabaja con multiples marcadores relacionados, simplemente se detectan los marcadores que + * se definieron en el archivo de configuración de objetos PUI y no soporta el uso de apuntadores. + * Si un marcador no es detectado entonces sus coordenadas no podrán ser calculadas a partir de las + * coordenadas de los demas marcadores (no existe relacion alguna entre ellos). + * Cuando se inicializa PUI en este modo debe utilizarse la funcion Pui::detectarMarcadoresSimples + * o Pui::detectarMarcadores la cual pregunta por el modo de operacion y realiza la correspondiente + * invocacion a Pui::detectarMarcadoresSimples o Pui::detectarYCalcularPosicionTodosMultiMarkers segun corresponda. + * + * 2. MODO_MULTI_MARKER : Trabaja con marcadores relacionados entre ellos. La posición de cada marcador es relativa a la de los + * demas. Por lo tanto, detectando por lo menos un marcador es capaz de deducir la posición en pantalla del resto. + * Este modo se utiliza junto con apuntadores que al tapar un marcador disparan la selección del correspondiente + * marcador. + * Cuando se inicializa PUI en este modo debe utilizarse la funcion Pui::detectarMarcadoresSimples + * o Pui::detectarMarcadores la cual pregunta por el modo de operacion y realiza la correspondiente + * invocacion a Pui::detectarMarcadoresSimples o Pui::detectarYCalcularPosicionTodosMultiMarkers segun corresponda. + * + * @param propiedadesDeteccion_RangosColor_Filename : Ruta completa de archivo de configuracion incluyendo Parametros para la detección del apuntador + * en caso que se utilice MODO_MULTI_MARKER + * + * @param configMarcadoresAR Si modo = Pui.MODO_MULTI_MARKER + * ==> Ruta completa del archivo de configuracion de Artoolkit que relaciona la posicion de los marcadores. + * Solamente soportado para el modo MODO_MULTI_MARKER + * Para mas informacion ver http://www.hitl.washington.edu/artoolkit/documentation/tutorialmulti.htm + * + * Si modo = Pui.MODO_SIMPLE + * ==> Ruta completa del archivo de configuracion donde se definen los marcadores que se van a utilizar + * Este archivo consiste en un conjunto de rutas que apuntan a los .patt correspondientes a cada marcador. + * El orden en que se declaran los archivos .patt debe ser el mismo orden en el que se declaran los objetos PUI + * cargados por la funcion Pui::leerConfiguracionObjetosPUI + * + * @param camera_para Archivo de calibracion de la camara + * + * @param vconf String de configuracion para gstreamer. En caso de ser vacio se utiliza el valor de la variable de ambiente ARTOOLKIT_CONFIG + * + * @param usarAlgoritmoRapido Utiliza los algoritmos Lite de artoolkit para la deteccion de marcadores. Esto supone un tiemp de procesamiento menor + * pero tambien una menor precision de la deteccion de los marcadores. En hardware con alto poder computacional no hay + * motivo para utilizar este tipo de algoritmo Lite. + * + * @param loopSpeed Posibles valores: Pui.FAST_SPEED_LOOP y Pui.NORMAL_SPEED_LOOP. Ver documentacion de estas dos constantes + * + * @param zoom En caso de haber compilado PUI con soporte para desplegar video (bandera GLUT_HABILITADO) entonces este + * parametro indica el zoom para desplegar video. + */ + void initPuiConCapturaDeVideo(int modo,char* propiedadesDeteccion_RangosColor_Filename,char * configMarcadoresAR,char * camera_para, + char *vconf,int usarAlgoritmoRapido,int loopSpeed,double zoom); + + + + + /****************************************************************************************************************/ + + /**************************************************OTRAS*********************************************************/ + + /** + * Setea la propiedad que indica si se quiere habilitar el modo de depuración del + * algoritmo de detección de seleccion mediante apuntador utilizando imagenes. + */ + void setDebugConImagenes(int debugConImagenes); + + /** + * Retorna la propiedad que indica si se quiere habilitar el modo de depuración del + * algoritmo de detección de seleccion mediante apuntador utilizando imagenes. + */ + int getDebugConImagenes(); + + /** + * Habilita o deshabilita la funcionalidad llamada histórico . + * La misma consta de llevar un conteo de las veces consecutivas que se detecto la + * seleccion de un mismo apuntador. Cuando se llega a un cierto valor establecido (cantHistorico) + * entonces recien se considerará como una seleccion y se reflejará en el resultado de la funcion Pui::detectarSeleccion + * + * El historico agrega robustez al algoritmo de detección evitando falsos positivos en los casos en que + * el apuntador no se detenga encima del marcador o que simplemente se haya introducido ruido en la imágen + * + * @param habilitar Indica si se desea habilitar o deshabilitar la funcionalidad de Historico + * @param cantHistorico Cantidad de selecciones consecutivas que deben detectarse sobre un mismo marcador para que se + * considere una seleccion real + * + * @param valorInicial Valor en que se inicializa el conteo, normalmente se utilizará el valor 0 + */ + void habilitarHistorico(bool habilitar,int cantHistorico,int valorInicial); + + /** + * Retorna true si y solo si la funcionalidad Historico está habilitada + */ + bool isHistoricoHabilitado(); + + + /** + * Libera recursos. + * Debe ser invocada solo al finalizar el uso de Pui + */ + void finish(); + + + + /** + * retorna la cantidad de imagenes procesadas por segundo y comienza el contador desde 0 nuevamente + * FIXME : Chequear la funcionalidad + */ + double getFPSAndResetCount(); + + /** + * retorna la cantidad de imagenes procesadas por segundo + * FIXME : Chequear la funcionalidad + */ + double getFPS(); + + /** + * Retorna un String con información de PUI (solo a modo informativo) + * + */ + char* getModuleInfo(); + + /** + * Establece modo debug mediante impresiones en consola + * + * @param debugMode 1 en caso de que se quiera habilitar el modo debug en consola + * 0 para deshabilitarlo + */ + void setDebugMode(int debugMode); + + /** + * @return Retorna 1 si esta el modo debug habilitado, + * 0 en caso contrario + */ + int getDebugMode(); +}; + + + + + +SWIGINTERNINLINE PyObject * +SWIG_FromCharPtr(const char *cptr) +{ + return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0)); +} + + +SWIGINTERNINLINE PyObject* + SWIG_From_bool (bool value) +{ + return PyBool_FromLong(value ? 1 : 0); +} + + +SWIGINTERN int +SWIG_AsVal_bool (PyObject *obj, bool *val) +{ + int r = PyObject_IsTrue(obj); + if (r == -1) + return SWIG_ERROR; + if (val) *val = r ? true : false; + return SWIG_OK; +} + + +SWIGINTERN int +SWIG_AsVal_float (PyObject * obj, float *val) +{ + double v; + int res = SWIG_AsVal_double (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < -FLT_MAX || v > FLT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< float >(v); + } + } + return res; +} + +#ifdef __cplusplus +extern "C" { +#endif +SWIGINTERN PyObject *_wrap_ARCoordMarcador_area_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ARCoordMarcador *arg1 = (ARCoordMarcador *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ARCoordMarcador_area_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ARCoordMarcador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ARCoordMarcador_area_set" "', argument " "1"" of type '" "ARCoordMarcador *""'"); + } + arg1 = reinterpret_cast< ARCoordMarcador * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ARCoordMarcador_area_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->area = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ARCoordMarcador_area_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ARCoordMarcador *arg1 = (ARCoordMarcador *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:ARCoordMarcador_area_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ARCoordMarcador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ARCoordMarcador_area_get" "', argument " "1"" of type '" "ARCoordMarcador *""'"); + } + arg1 = reinterpret_cast< ARCoordMarcador * >(argp1); + result = (int) ((arg1)->area); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ARCoordMarcador_centro_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ARCoordMarcador *arg1 = (ARCoordMarcador *) 0 ; + double *arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ARCoordMarcador_centro_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ARCoordMarcador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ARCoordMarcador_centro_set" "', argument " "1"" of type '" "ARCoordMarcador *""'"); + } + arg1 = reinterpret_cast< ARCoordMarcador * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ARCoordMarcador_centro_set" "', argument " "2"" of type '" "double [2]""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)2; ++ii) arg1->centro[ii] = arg2[ii]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""centro""' of type '""double [2]""'"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ARCoordMarcador_centro_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ARCoordMarcador *arg1 = (ARCoordMarcador *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + double *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ARCoordMarcador_centro_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ARCoordMarcador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ARCoordMarcador_centro_get" "', argument " "1"" of type '" "ARCoordMarcador *""'"); + } + arg1 = reinterpret_cast< ARCoordMarcador * >(argp1); + result = (double *)(double *) ((arg1)->centro); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ARCoordMarcador_vertex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ARCoordMarcador *arg1 = (ARCoordMarcador *) 0 ; + double (*arg2)[2] ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ARCoordMarcador_vertex_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ARCoordMarcador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ARCoordMarcador_vertex_set" "', argument " "1"" of type '" "ARCoordMarcador *""'"); + } + arg1 = reinterpret_cast< ARCoordMarcador * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_a_2__double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ARCoordMarcador_vertex_set" "', argument " "2"" of type '" "double [4][2]""'"); + } + arg2 = reinterpret_cast< double (*)[2] >(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)4; ++ii) { + if (arg2[ii]) { + size_t jj = 0; + for (; jj < (size_t)2; ++jj) arg1->vertex[ii][jj] = arg2[ii][jj]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""vertex""' of type '""double [4][2]""'"); + } + } + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""vertex""' of type '""double [4][2]""'"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ARCoordMarcador_vertex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ARCoordMarcador *arg1 = (ARCoordMarcador *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + double (*result)[2] = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ARCoordMarcador_vertex_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ARCoordMarcador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ARCoordMarcador_vertex_get" "', argument " "1"" of type '" "ARCoordMarcador *""'"); + } + arg1 = reinterpret_cast< ARCoordMarcador * >(argp1); + result = (double (*)[2])(double (*)[2]) ((arg1)->vertex); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_2__double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ARCoordMarcador_visible_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ARCoordMarcador *arg1 = (ARCoordMarcador *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ARCoordMarcador_visible_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ARCoordMarcador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ARCoordMarcador_visible_set" "', argument " "1"" of type '" "ARCoordMarcador *""'"); + } + arg1 = reinterpret_cast< ARCoordMarcador * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ARCoordMarcador_visible_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->visible = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ARCoordMarcador_visible_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ARCoordMarcador *arg1 = (ARCoordMarcador *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:ARCoordMarcador_visible_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ARCoordMarcador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ARCoordMarcador_visible_get" "', argument " "1"" of type '" "ARCoordMarcador *""'"); + } + arg1 = reinterpret_cast< ARCoordMarcador * >(argp1); + result = (int) ((arg1)->visible); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ARCoordMarcador_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ARCoordMarcador *arg1 = (ARCoordMarcador *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ARCoordMarcador_id_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ARCoordMarcador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ARCoordMarcador_id_set" "', argument " "1"" of type '" "ARCoordMarcador *""'"); + } + arg1 = reinterpret_cast< ARCoordMarcador * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ARCoordMarcador_id_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->id = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ARCoordMarcador_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ARCoordMarcador *arg1 = (ARCoordMarcador *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:ARCoordMarcador_id_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ARCoordMarcador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ARCoordMarcador_id_get" "', argument " "1"" of type '" "ARCoordMarcador *""'"); + } + arg1 = reinterpret_cast< ARCoordMarcador * >(argp1); + result = (int) ((arg1)->id); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ARCoordMarcador_cf_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ARCoordMarcador *arg1 = (ARCoordMarcador *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ARCoordMarcador_cf_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ARCoordMarcador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ARCoordMarcador_cf_set" "', argument " "1"" of type '" "ARCoordMarcador *""'"); + } + arg1 = reinterpret_cast< ARCoordMarcador * >(argp1); + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ARCoordMarcador_cf_set" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + if (arg1) (arg1)->cf = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ARCoordMarcador_cf_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ARCoordMarcador *arg1 = (ARCoordMarcador *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + double result; + + if (!PyArg_ParseTuple(args,(char *)"O:ARCoordMarcador_cf_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ARCoordMarcador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ARCoordMarcador_cf_get" "', argument " "1"" of type '" "ARCoordMarcador *""'"); + } + arg1 = reinterpret_cast< ARCoordMarcador * >(argp1); + result = (double) ((arg1)->cf); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ARCoordMarcador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ARCoordMarcador *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_ARCoordMarcador")) SWIG_fail; + result = (ARCoordMarcador *)new ARCoordMarcador(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ARCoordMarcador, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_ARCoordMarcador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ARCoordMarcador *arg1 = (ARCoordMarcador *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_ARCoordMarcador",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ARCoordMarcador, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ARCoordMarcador" "', argument " "1"" of type '" "ARCoordMarcador *""'"); + } + arg1 = reinterpret_cast< ARCoordMarcador * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ARCoordMarcador_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_ARCoordMarcador, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_Elemento_idPatt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Elemento *arg1 = (Elemento *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Elemento_idPatt_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Elemento, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elemento_idPatt_set" "', argument " "1"" of type '" "Elemento *""'"); + } + arg1 = reinterpret_cast< Elemento * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elemento_idPatt_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->idPatt = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Elemento_idPatt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Elemento *arg1 = (Elemento *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Elemento_idPatt_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Elemento, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elemento_idPatt_get" "', argument " "1"" of type '" "Elemento *""'"); + } + arg1 = reinterpret_cast< Elemento * >(argp1); + result = (int) ((arg1)->idPatt); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Elemento_imagen_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Elemento *arg1 = (Elemento *) 0 ; + char *arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2[255] ; + int res2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Elemento_imagen_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Elemento, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elemento_imagen_set" "', argument " "1"" of type '" "Elemento *""'"); + } + arg1 = reinterpret_cast< Elemento * >(argp1); + res2 = SWIG_AsCharArray(obj1, temp2, 255); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elemento_imagen_set" "', argument " "2"" of type '" "char [255]""'"); + } + arg2 = reinterpret_cast< char * >(temp2); + if (arg2) memcpy(arg1->imagen,arg2,255*sizeof(char)); + else memset(arg1->imagen,0,255*sizeof(char)); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Elemento_imagen_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Elemento *arg1 = (Elemento *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Elemento_imagen_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Elemento, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elemento_imagen_get" "', argument " "1"" of type '" "Elemento *""'"); + } + arg1 = reinterpret_cast< Elemento * >(argp1); + result = (char *)(char *) ((arg1)->imagen); + { + size_t size = 255; + + while (size && (result[size - 1] == '\0')) --size; + + resultobj = SWIG_FromCharPtrAndSize(result, size); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Elemento_sonido_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Elemento *arg1 = (Elemento *) 0 ; + char *arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2[255] ; + int res2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Elemento_sonido_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Elemento, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elemento_sonido_set" "', argument " "1"" of type '" "Elemento *""'"); + } + arg1 = reinterpret_cast< Elemento * >(argp1); + res2 = SWIG_AsCharArray(obj1, temp2, 255); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elemento_sonido_set" "', argument " "2"" of type '" "char [255]""'"); + } + arg2 = reinterpret_cast< char * >(temp2); + if (arg2) memcpy(arg1->sonido,arg2,255*sizeof(char)); + else memset(arg1->sonido,0,255*sizeof(char)); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Elemento_sonido_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Elemento *arg1 = (Elemento *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Elemento_sonido_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Elemento, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elemento_sonido_get" "', argument " "1"" of type '" "Elemento *""'"); + } + arg1 = reinterpret_cast< Elemento * >(argp1); + result = (char *)(char *) ((arg1)->sonido); + { + size_t size = 255; + + while (size && (result[size - 1] == '\0')) --size; + + resultobj = SWIG_FromCharPtrAndSize(result, size); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Elemento_nombre_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Elemento *arg1 = (Elemento *) 0 ; + char *arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2[255] ; + int res2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Elemento_nombre_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Elemento, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elemento_nombre_set" "', argument " "1"" of type '" "Elemento *""'"); + } + arg1 = reinterpret_cast< Elemento * >(argp1); + res2 = SWIG_AsCharArray(obj1, temp2, 255); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elemento_nombre_set" "', argument " "2"" of type '" "char [255]""'"); + } + arg2 = reinterpret_cast< char * >(temp2); + if (arg2) memcpy(arg1->nombre,arg2,255*sizeof(char)); + else memset(arg1->nombre,0,255*sizeof(char)); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Elemento_nombre_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Elemento *arg1 = (Elemento *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Elemento_nombre_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Elemento, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elemento_nombre_get" "', argument " "1"" of type '" "Elemento *""'"); + } + arg1 = reinterpret_cast< Elemento * >(argp1); + result = (char *)(char *) ((arg1)->nombre); + { + size_t size = 255; + + while (size && (result[size - 1] == '\0')) --size; + + resultobj = SWIG_FromCharPtrAndSize(result, size); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Elemento_conjunto_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Elemento *arg1 = (Elemento *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Elemento_conjunto_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Elemento, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elemento_conjunto_set" "', argument " "1"" of type '" "Elemento *""'"); + } + arg1 = reinterpret_cast< Elemento * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elemento_conjunto_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->conjunto = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Elemento_conjunto_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Elemento *arg1 = (Elemento *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Elemento_conjunto_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Elemento, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elemento_conjunto_get" "', argument " "1"" of type '" "Elemento *""'"); + } + arg1 = reinterpret_cast< Elemento * >(argp1); + result = (int) ((arg1)->conjunto); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Elemento_idElementoRelacionado_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Elemento *arg1 = (Elemento *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Elemento_idElementoRelacionado_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Elemento, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elemento_idElementoRelacionado_set" "', argument " "1"" of type '" "Elemento *""'"); + } + arg1 = reinterpret_cast< Elemento * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elemento_idElementoRelacionado_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->idElementoRelacionado = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Elemento_idElementoRelacionado_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Elemento *arg1 = (Elemento *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Elemento_idElementoRelacionado_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Elemento, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elemento_idElementoRelacionado_get" "', argument " "1"" of type '" "Elemento *""'"); + } + arg1 = reinterpret_cast< Elemento * >(argp1); + result = (int) ((arg1)->idElementoRelacionado); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Elemento_nombreRelacion_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Elemento *arg1 = (Elemento *) 0 ; + char *arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + char temp2[255] ; + int res2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Elemento_nombreRelacion_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Elemento, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elemento_nombreRelacion_set" "', argument " "1"" of type '" "Elemento *""'"); + } + arg1 = reinterpret_cast< Elemento * >(argp1); + res2 = SWIG_AsCharArray(obj1, temp2, 255); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Elemento_nombreRelacion_set" "', argument " "2"" of type '" "char [255]""'"); + } + arg2 = reinterpret_cast< char * >(temp2); + if (arg2) memcpy(arg1->nombreRelacion,arg2,255*sizeof(char)); + else memset(arg1->nombreRelacion,0,255*sizeof(char)); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Elemento_nombreRelacion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Elemento *arg1 = (Elemento *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Elemento_nombreRelacion_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Elemento, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elemento_nombreRelacion_get" "', argument " "1"" of type '" "Elemento *""'"); + } + arg1 = reinterpret_cast< Elemento * >(argp1); + result = (char *)(char *) ((arg1)->nombreRelacion); + { + size_t size = 255; + + while (size && (result[size - 1] == '\0')) --size; + + resultobj = SWIG_FromCharPtrAndSize(result, size); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Elemento_idImagenSDL_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Elemento *arg1 = (Elemento *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Elemento_idImagenSDL_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Elemento, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elemento_idImagenSDL_set" "', argument " "1"" of type '" "Elemento *""'"); + } + arg1 = reinterpret_cast< Elemento * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Elemento_idImagenSDL_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->idImagenSDL = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Elemento_idImagenSDL_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Elemento *arg1 = (Elemento *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Elemento_idImagenSDL_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Elemento, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Elemento_idImagenSDL_get" "', argument " "1"" of type '" "Elemento *""'"); + } + arg1 = reinterpret_cast< Elemento * >(argp1); + result = (int) ((arg1)->idImagenSDL); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Elemento(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Elemento *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_Elemento")) SWIG_fail; + result = (Elemento *)new Elemento(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Elemento, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_Elemento(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Elemento *arg1 = (Elemento *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_Elemento",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Elemento, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Elemento" "', argument " "1"" of type '" "Elemento *""'"); + } + arg1 = reinterpret_cast< Elemento * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *Elemento_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_Elemento, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_Historico_tope_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Historico *arg1 = (Historico *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Historico_tope_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Historico, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Historico_tope_set" "', argument " "1"" of type '" "Historico *""'"); + } + arg1 = reinterpret_cast< Historico * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Historico_tope_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->tope = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Historico_tope_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Historico *arg1 = (Historico *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Historico_tope_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Historico, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Historico_tope_get" "', argument " "1"" of type '" "Historico *""'"); + } + arg1 = reinterpret_cast< Historico * >(argp1); + result = (int) ((arg1)->tope); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Historico_cantHistorico_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Historico *arg1 = (Historico *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Historico_cantHistorico_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Historico, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Historico_cantHistorico_set" "', argument " "1"" of type '" "Historico *""'"); + } + arg1 = reinterpret_cast< Historico * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Historico_cantHistorico_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->cantHistorico = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Historico_cantHistorico_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Historico *arg1 = (Historico *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Historico_cantHistorico_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Historico, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Historico_cantHistorico_get" "', argument " "1"" of type '" "Historico *""'"); + } + arg1 = reinterpret_cast< Historico * >(argp1); + result = (int) ((arg1)->cantHistorico); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Historico_historicoElementos_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Historico *arg1 = (Historico *) 0 ; + int *arg2 = (int *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Historico_historicoElementos_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Historico, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Historico_historicoElementos_set" "', argument " "1"" of type '" "Historico *""'"); + } + arg1 = reinterpret_cast< Historico * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Historico_historicoElementos_set" "', argument " "2"" of type '" "int *""'"); + } + arg2 = reinterpret_cast< int * >(argp2); + if (arg1) (arg1)->historicoElementos = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Historico_historicoElementos_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Historico *arg1 = (Historico *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Historico_historicoElementos_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Historico, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Historico_historicoElementos_get" "', argument " "1"" of type '" "Historico *""'"); + } + arg1 = reinterpret_cast< Historico * >(argp1); + result = (int *) ((arg1)->historicoElementos); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Historico(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Historico *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_Historico")) SWIG_fail; + result = (Historico *)new Historico(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Historico, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_Historico(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Historico *arg1 = (Historico *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_Historico",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Historico, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Historico" "', argument " "1"" of type '" "Historico *""'"); + } + arg1 = reinterpret_cast< Historico * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *Historico_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_Historico, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_RangosColorApuntador_hmin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + RangosColorApuntador *arg1 = (RangosColorApuntador *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:RangosColorApuntador_hmin_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RangosColorApuntador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangosColorApuntador_hmin_set" "', argument " "1"" of type '" "RangosColorApuntador *""'"); + } + arg1 = reinterpret_cast< RangosColorApuntador * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RangosColorApuntador_hmin_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->hmin = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_RangosColorApuntador_hmin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + RangosColorApuntador *arg1 = (RangosColorApuntador *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:RangosColorApuntador_hmin_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RangosColorApuntador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangosColorApuntador_hmin_get" "', argument " "1"" of type '" "RangosColorApuntador *""'"); + } + arg1 = reinterpret_cast< RangosColorApuntador * >(argp1); + result = (int) ((arg1)->hmin); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_RangosColorApuntador_hmax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + RangosColorApuntador *arg1 = (RangosColorApuntador *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:RangosColorApuntador_hmax_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RangosColorApuntador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangosColorApuntador_hmax_set" "', argument " "1"" of type '" "RangosColorApuntador *""'"); + } + arg1 = reinterpret_cast< RangosColorApuntador * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RangosColorApuntador_hmax_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->hmax = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_RangosColorApuntador_hmax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + RangosColorApuntador *arg1 = (RangosColorApuntador *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:RangosColorApuntador_hmax_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RangosColorApuntador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangosColorApuntador_hmax_get" "', argument " "1"" of type '" "RangosColorApuntador *""'"); + } + arg1 = reinterpret_cast< RangosColorApuntador * >(argp1); + result = (int) ((arg1)->hmax); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_RangosColorApuntador_smin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + RangosColorApuntador *arg1 = (RangosColorApuntador *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:RangosColorApuntador_smin_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RangosColorApuntador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangosColorApuntador_smin_set" "', argument " "1"" of type '" "RangosColorApuntador *""'"); + } + arg1 = reinterpret_cast< RangosColorApuntador * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RangosColorApuntador_smin_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->smin = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_RangosColorApuntador_smin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + RangosColorApuntador *arg1 = (RangosColorApuntador *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:RangosColorApuntador_smin_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RangosColorApuntador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangosColorApuntador_smin_get" "', argument " "1"" of type '" "RangosColorApuntador *""'"); + } + arg1 = reinterpret_cast< RangosColorApuntador * >(argp1); + result = (int) ((arg1)->smin); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_RangosColorApuntador_smax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + RangosColorApuntador *arg1 = (RangosColorApuntador *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:RangosColorApuntador_smax_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RangosColorApuntador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangosColorApuntador_smax_set" "', argument " "1"" of type '" "RangosColorApuntador *""'"); + } + arg1 = reinterpret_cast< RangosColorApuntador * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RangosColorApuntador_smax_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->smax = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_RangosColorApuntador_smax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + RangosColorApuntador *arg1 = (RangosColorApuntador *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:RangosColorApuntador_smax_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RangosColorApuntador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangosColorApuntador_smax_get" "', argument " "1"" of type '" "RangosColorApuntador *""'"); + } + arg1 = reinterpret_cast< RangosColorApuntador * >(argp1); + result = (int) ((arg1)->smax); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_RangosColorApuntador_vmin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + RangosColorApuntador *arg1 = (RangosColorApuntador *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:RangosColorApuntador_vmin_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RangosColorApuntador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangosColorApuntador_vmin_set" "', argument " "1"" of type '" "RangosColorApuntador *""'"); + } + arg1 = reinterpret_cast< RangosColorApuntador * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RangosColorApuntador_vmin_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->vmin = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_RangosColorApuntador_vmin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + RangosColorApuntador *arg1 = (RangosColorApuntador *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:RangosColorApuntador_vmin_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RangosColorApuntador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangosColorApuntador_vmin_get" "', argument " "1"" of type '" "RangosColorApuntador *""'"); + } + arg1 = reinterpret_cast< RangosColorApuntador * >(argp1); + result = (int) ((arg1)->vmin); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_RangosColorApuntador_vmax_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + RangosColorApuntador *arg1 = (RangosColorApuntador *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:RangosColorApuntador_vmax_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RangosColorApuntador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangosColorApuntador_vmax_set" "', argument " "1"" of type '" "RangosColorApuntador *""'"); + } + arg1 = reinterpret_cast< RangosColorApuntador * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RangosColorApuntador_vmax_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->vmax = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_RangosColorApuntador_vmax_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + RangosColorApuntador *arg1 = (RangosColorApuntador *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:RangosColorApuntador_vmax_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RangosColorApuntador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RangosColorApuntador_vmax_get" "', argument " "1"" of type '" "RangosColorApuntador *""'"); + } + arg1 = reinterpret_cast< RangosColorApuntador * >(argp1); + result = (int) ((arg1)->vmax); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_RangosColorApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + RangosColorApuntador *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_RangosColorApuntador")) SWIG_fail; + result = (RangosColorApuntador *)new RangosColorApuntador(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RangosColorApuntador, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_RangosColorApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + RangosColorApuntador *arg1 = (RangosColorApuntador *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_RangosColorApuntador",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_RangosColorApuntador, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RangosColorApuntador" "', argument " "1"" of type '" "RangosColorApuntador *""'"); + } + arg1 = reinterpret_cast< RangosColorApuntador * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *RangosColorApuntador_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_RangosColorApuntador, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_ResultadosCalibracion_areas_minimas_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ResultadosCalibracion *arg1 = (ResultadosCalibracion *) 0 ; + int *arg2 = (int *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ResultadosCalibracion_areas_minimas_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ResultadosCalibracion, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResultadosCalibracion_areas_minimas_set" "', argument " "1"" of type '" "ResultadosCalibracion *""'"); + } + arg1 = reinterpret_cast< ResultadosCalibracion * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResultadosCalibracion_areas_minimas_set" "', argument " "2"" of type '" "int *""'"); + } + arg2 = reinterpret_cast< int * >(argp2); + if (arg1) (arg1)->areas_minimas = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ResultadosCalibracion_areas_minimas_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ResultadosCalibracion *arg1 = (ResultadosCalibracion *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ResultadosCalibracion_areas_minimas_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ResultadosCalibracion, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResultadosCalibracion_areas_minimas_get" "', argument " "1"" of type '" "ResultadosCalibracion *""'"); + } + arg1 = reinterpret_cast< ResultadosCalibracion * >(argp1); + result = (int *) ((arg1)->areas_minimas); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ResultadosCalibracion_areas_maximas_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ResultadosCalibracion *arg1 = (ResultadosCalibracion *) 0 ; + int *arg2 = (int *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ResultadosCalibracion_areas_maximas_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ResultadosCalibracion, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResultadosCalibracion_areas_maximas_set" "', argument " "1"" of type '" "ResultadosCalibracion *""'"); + } + arg1 = reinterpret_cast< ResultadosCalibracion * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResultadosCalibracion_areas_maximas_set" "', argument " "2"" of type '" "int *""'"); + } + arg2 = reinterpret_cast< int * >(argp2); + if (arg1) (arg1)->areas_maximas = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ResultadosCalibracion_areas_maximas_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ResultadosCalibracion *arg1 = (ResultadosCalibracion *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ResultadosCalibracion_areas_maximas_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ResultadosCalibracion, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResultadosCalibracion_areas_maximas_get" "', argument " "1"" of type '" "ResultadosCalibracion *""'"); + } + arg1 = reinterpret_cast< ResultadosCalibracion * >(argp1); + result = (int *) ((arg1)->areas_maximas); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ResultadosCalibracion_relaciones_promedio_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ResultadosCalibracion *arg1 = (ResultadosCalibracion *) 0 ; + double *arg2 = (double *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:ResultadosCalibracion_relaciones_promedio_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ResultadosCalibracion, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResultadosCalibracion_relaciones_promedio_set" "', argument " "1"" of type '" "ResultadosCalibracion *""'"); + } + arg1 = reinterpret_cast< ResultadosCalibracion * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ResultadosCalibracion_relaciones_promedio_set" "', argument " "2"" of type '" "double *""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + if (arg1) (arg1)->relaciones_promedio = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ResultadosCalibracion_relaciones_promedio_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ResultadosCalibracion *arg1 = (ResultadosCalibracion *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + double *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:ResultadosCalibracion_relaciones_promedio_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ResultadosCalibracion, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ResultadosCalibracion_relaciones_promedio_get" "', argument " "1"" of type '" "ResultadosCalibracion *""'"); + } + arg1 = reinterpret_cast< ResultadosCalibracion * >(argp1); + result = (double *) ((arg1)->relaciones_promedio); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ResultadosCalibracion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ResultadosCalibracion *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_ResultadosCalibracion")) SWIG_fail; + result = (ResultadosCalibracion *)new ResultadosCalibracion(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ResultadosCalibracion, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_ResultadosCalibracion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + ResultadosCalibracion *arg1 = (ResultadosCalibracion *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_ResultadosCalibracion",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ResultadosCalibracion, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ResultadosCalibracion" "', argument " "1"" of type '" "ResultadosCalibracion *""'"); + } + arg1 = reinterpret_cast< ResultadosCalibracion * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ResultadosCalibracion_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_ResultadosCalibracion, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_CoordApuntador_area_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + CoordApuntador *arg1 = (CoordApuntador *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:CoordApuntador_area_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoordApuntador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordApuntador_area_set" "', argument " "1"" of type '" "CoordApuntador *""'"); + } + arg1 = reinterpret_cast< CoordApuntador * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoordApuntador_area_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->area = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CoordApuntador_area_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + CoordApuntador *arg1 = (CoordApuntador *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:CoordApuntador_area_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoordApuntador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordApuntador_area_get" "', argument " "1"" of type '" "CoordApuntador *""'"); + } + arg1 = reinterpret_cast< CoordApuntador * >(argp1); + result = (int) ((arg1)->area); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CoordApuntador_centro_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + CoordApuntador *arg1 = (CoordApuntador *) 0 ; + double *arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:CoordApuntador_centro_set",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoordApuntador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordApuntador_centro_set" "', argument " "1"" of type '" "CoordApuntador *""'"); + } + arg1 = reinterpret_cast< CoordApuntador * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoordApuntador_centro_set" "', argument " "2"" of type '" "double [2]""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)2; ++ii) arg1->centro[ii] = arg2[ii]; + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""centro""' of type '""double [2]""'"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CoordApuntador_centro_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + CoordApuntador *arg1 = (CoordApuntador *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + double *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:CoordApuntador_centro_get",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoordApuntador, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordApuntador_centro_get" "', argument " "1"" of type '" "CoordApuntador *""'"); + } + arg1 = reinterpret_cast< CoordApuntador * >(argp1); + result = (double *)(double *) ((arg1)->centro); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_CoordApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + CoordApuntador *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_CoordApuntador")) SWIG_fail; + result = (CoordApuntador *)new CoordApuntador(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_CoordApuntador, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_CoordApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + CoordApuntador *arg1 = (CoordApuntador *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_CoordApuntador",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_CoordApuntador, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CoordApuntador" "', argument " "1"" of type '" "CoordApuntador *""'"); + } + arg1 = reinterpret_cast< CoordApuntador * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *CoordApuntador_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_CoordApuntador, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_Pui_insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + unsigned char *arg2 = (unsigned char *) 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_insert",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_insert" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + { + if (!PyString_Check(obj1)) { + PyErr_SetString(PyExc_ValueError,"Expected a string"); + return NULL; + } + arg2 = reinterpret_cast<unsigned char *>(PyString_AsString(obj1)); + arg3 = PyString_Size(obj1); + } + result = (int)(arg1)->insert(arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_out(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_out",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_out" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + { + binary_data bin_data = (arg1)->out(); + int size = bin_data.size; + if(size==0){ + return Py_BuildValue(""); + } + /* para crear el array en un espacio de memoria compartida ya creado y pasado por parametro + array = (PyArrayObject *) PyArray_ContiguousFromObject(input,PyArray_UBYTE,1,1); + */ + + + PyArrayObject *array = (PyArrayObject *) PyArray_FromDims(1, &size,PyArray_UBYTE); + if (array == NULL){ + PyErr_SetString(PyExc_ValueError,"Error creando PyArray"); + return Py_BuildValue(""); + } + + //Una vez creado el array copio la info + memcpy(array->data,(unsigned char *)(bin_data.data),size); + + resultobj = (PyObject *)array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Pui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)":new_Pui")) SWIG_fail; + result = (Pui *)new Pui(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Pui, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_Pui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:delete_Pui",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Pui" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + delete arg1; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_leerConfiguracionObjetosPUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Pui_leerConfiguracionObjetosPUI",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_leerConfiguracionObjetosPUI" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pui_leerConfiguracionObjetosPUI" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pui_leerConfiguracionObjetosPUI" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (int)(arg1)->leerConfiguracionObjetosPUI((char const *)arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_leerPatternsModoSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_leerPatternsModoSimple",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_leerPatternsModoSimple" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pui_leerPatternsModoSimple" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (int)(arg1)->leerPatternsModoSimple((char const *)arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_imprimirPropiedadesObjetosPUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_imprimirPropiedadesObjetosPUI",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_imprimirPropiedadesObjetosPUI" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + (arg1)->imprimirPropiedadesObjetosPUI(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getNombreObjetoPUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_getNombreObjetoPUI",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getNombreObjetoPUI" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_getNombreObjetoPUI" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (char *)(arg1)->getNombreObjetoPUI(arg2); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getSonidoObjetoPUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_getSonidoObjetoPUI",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getSonidoObjetoPUI" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_getSonidoObjetoPUI" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (char *)(arg1)->getSonidoObjetoPUI(arg2); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getImagenObjetoPUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_getImagenObjetoPUI",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getImagenObjetoPUI" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_getImagenObjetoPUI" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (char *)(arg1)->getImagenObjetoPUI(arg2); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getSonidoError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getSonidoError",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getSonidoError" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (char *)(arg1)->getSonidoError(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getSonidoOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getSonidoOk",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getSonidoOk" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (char *)(arg1)->getSonidoOk(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_esRelacionCorrecta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Pui_esRelacionCorrecta",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_esRelacionCorrecta" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_esRelacionCorrecta" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pui_esRelacionCorrecta" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (bool)(arg1)->esRelacionCorrecta(arg2,arg3); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getConjuntoObjetoPui(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_getConjuntoObjetoPui",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getConjuntoObjetoPui" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_getConjuntoObjetoPui" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)(arg1)->getConjuntoObjetoPui(arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getIdElementoRelacionado(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_getIdElementoRelacionado",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getIdElementoRelacionado" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_getIdElementoRelacionado" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)(arg1)->getIdElementoRelacionado(arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getNombreRelacionObjetoPUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_getNombreRelacionObjetoPUI",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getNombreRelacionObjetoPUI" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_getNombreRelacionObjetoPUI" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (char *)(arg1)->getNombreRelacionObjetoPUI(arg2); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_detectarSeleccion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_detectarSeleccion",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_detectarSeleccion" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (int)(arg1)->detectarSeleccion(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_initDeteccionApuntador__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + PropiedadesDeteccionApuntador arg2 ; + RangosColorApuntador arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + void *argp3 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Pui_initDeteccionApuntador",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_initDeteccionApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_PropiedadesDeteccionApuntador, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pui_initDeteccionApuntador" "', argument " "2"" of type '" "PropiedadesDeteccionApuntador""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pui_initDeteccionApuntador" "', argument " "2"" of type '" "PropiedadesDeteccionApuntador""'"); + } else { + PropiedadesDeteccionApuntador * temp = reinterpret_cast< PropiedadesDeteccionApuntador * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + { + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_RangosColorApuntador, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pui_initDeteccionApuntador" "', argument " "3"" of type '" "RangosColorApuntador""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pui_initDeteccionApuntador" "', argument " "3"" of type '" "RangosColorApuntador""'"); + } else { + RangosColorApuntador * temp = reinterpret_cast< RangosColorApuntador * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + (arg1)->initDeteccionApuntador(arg2,arg3); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_initDeteccionApuntador__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_initDeteccionApuntador",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_initDeteccionApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pui_initDeteccionApuntador" "', argument " "2"" of type '" "char *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + result = (int)(arg1)->initDeteccionApuntador(arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_initDeteccionApuntador(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[4]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 3); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pui, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Pui_initDeteccionApuntador__SWIG_1(self, args); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pui, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_PropiedadesDeteccionApuntador, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_RangosColorApuntador, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Pui_initDeteccionApuntador__SWIG_0(self, args); + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Pui_initDeteccionApuntador'.\n" + " Possible C/C++ prototypes are:\n" + " initDeteccionApuntador(Pui *,PropiedadesDeteccionApuntador,RangosColorApuntador)\n" + " initDeteccionApuntador(Pui *,char *)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getPropiedadesDeteccionApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PropiedadesDeteccionApuntador result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getPropiedadesDeteccionApuntador",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getPropiedadesDeteccionApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (arg1)->getPropiedadesDeteccionApuntador(); + resultobj = SWIG_NewPointerObj((new PropiedadesDeteccionApuntador(static_cast< const PropiedadesDeteccionApuntador& >(result))), SWIGTYPE_p_PropiedadesDeteccionApuntador, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_setPropiedadesDeteccionApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + PropiedadesDeteccionApuntador arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_setPropiedadesDeteccionApuntador",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_setPropiedadesDeteccionApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_PropiedadesDeteccionApuntador, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pui_setPropiedadesDeteccionApuntador" "', argument " "2"" of type '" "PropiedadesDeteccionApuntador""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pui_setPropiedadesDeteccionApuntador" "', argument " "2"" of type '" "PropiedadesDeteccionApuntador""'"); + } else { + PropiedadesDeteccionApuntador * temp = reinterpret_cast< PropiedadesDeteccionApuntador * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (arg1)->setPropiedadesDeteccionApuntador(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getPropiedadesColorApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + RangosColorApuntador result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getPropiedadesColorApuntador",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getPropiedadesColorApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (arg1)->getPropiedadesColorApuntador(); + resultobj = SWIG_NewPointerObj((new RangosColorApuntador(static_cast< const RangosColorApuntador& >(result))), SWIGTYPE_p_RangosColorApuntador, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_setPropiedadesColorApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + RangosColorApuntador arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_setPropiedadesColorApuntador",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_setPropiedadesColorApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_RangosColorApuntador, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pui_setPropiedadesColorApuntador" "', argument " "2"" of type '" "RangosColorApuntador""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pui_setPropiedadesColorApuntador" "', argument " "2"" of type '" "RangosColorApuntador""'"); + } else { + RangosColorApuntador * temp = reinterpret_cast< RangosColorApuntador * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + (arg1)->setPropiedadesColorApuntador(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_setHminApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_setHminApuntador",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_setHminApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_setHminApuntador" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->setHminApuntador(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getHminApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getHminApuntador",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getHminApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (int)(arg1)->getHminApuntador(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_setHmaxApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_setHmaxApuntador",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_setHmaxApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_setHmaxApuntador" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->setHmaxApuntador(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getHmaxApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getHmaxApuntador",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getHmaxApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (int)(arg1)->getHmaxApuntador(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_setSminApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_setSminApuntador",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_setSminApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_setSminApuntador" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->setSminApuntador(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getSminApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getSminApuntador",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getSminApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (int)(arg1)->getSminApuntador(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_setSmaxApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_setSmaxApuntador",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_setSmaxApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_setSmaxApuntador" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->setSmaxApuntador(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getSmaxApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getSmaxApuntador",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getSmaxApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (int)(arg1)->getSmaxApuntador(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_setVminApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_setVminApuntador",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_setVminApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_setVminApuntador" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->setVminApuntador(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getVminApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getVminApuntador",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getVminApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (int)(arg1)->getVminApuntador(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_setVmaxApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_setVmaxApuntador",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_setVmaxApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_setVmaxApuntador" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->setVmaxApuntador(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getVmaxApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getVmaxApuntador",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getVmaxApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (int)(arg1)->getVmaxApuntador(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_procesarDatosCalibracion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_procesarDatosCalibracion",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_procesarDatosCalibracion" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + (arg1)->procesarDatosCalibracion(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_guardarDatosCalibracion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_guardarDatosCalibracion",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_guardarDatosCalibracion" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pui_guardarDatosCalibracion" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + (arg1)->guardarDatosCalibracion((char const *)arg2); + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_initPropiedadesCalibracion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + int arg3 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOO:Pui_initPropiedadesCalibracion",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_initPropiedadesCalibracion" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_initPropiedadesCalibracion" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pui_initPropiedadesCalibracion" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pui_initPropiedadesCalibracion" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Pui_initPropiedadesCalibracion" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + (arg1)->initPropiedadesCalibracion(arg2,arg3,arg4,arg5); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_leerConfiguracionCalibracion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + char **arg4 = (char **) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:Pui_leerConfiguracionCalibracion",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_leerConfiguracionCalibracion" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pui_leerConfiguracionCalibracion" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pui_leerConfiguracionCalibracion" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_char, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Pui_leerConfiguracionCalibracion" "', argument " "4"" of type '" "char **""'"); + } + arg4 = reinterpret_cast< char ** >(argp4); + result = (int)(arg1)->leerConfiguracionCalibracion((char const *)arg2,arg3,arg4); + resultobj = SWIG_From_int(static_cast< int >(result)); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_calibrarThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_calibrarThreshold",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_calibrarThreshold" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_calibrarThreshold" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->calibrarThreshold(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_setBrillo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + char *arg3 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Pui_setBrillo",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_setBrillo" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_setBrillo" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pui_setBrillo" "', argument " "3"" of type '" "char *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + (arg1)->setBrillo(arg2,arg3); + resultobj = SWIG_Py_Void(); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_setAutoWhiteBalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + char *arg3 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Pui_setAutoWhiteBalance",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_setAutoWhiteBalance" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_setAutoWhiteBalance" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pui_setAutoWhiteBalance" "', argument " "3"" of type '" "char *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + (arg1)->setAutoWhiteBalance(arg2,arg3); + resultobj = SWIG_Py_Void(); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_setAutoGain(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + char *arg3 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Pui_setAutoGain",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_setAutoGain" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_setAutoGain" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pui_setAutoGain" "', argument " "3"" of type '" "char *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + (arg1)->setAutoGain(arg2,arg3); + resultobj = SWIG_Py_Void(); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_setHorizontalFlip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + char *arg3 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Pui_setHorizontalFlip",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_setHorizontalFlip" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_setHorizontalFlip" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pui_setHorizontalFlip" "', argument " "3"" of type '" "char *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + (arg1)->setHorizontalFlip(arg2,arg3); + resultobj = SWIG_Py_Void(); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_abrirVentanaGrafica(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_abrirVentanaGrafica",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_abrirVentanaGrafica" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + (arg1)->abrirVentanaGrafica(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_cerrarVentanaGrafica(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_cerrarVentanaGrafica",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_cerrarVentanaGrafica" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + (arg1)->cerrarVentanaGrafica(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_desplegarImagenAR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_desplegarImagenAR",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_desplegarImagenAR" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_desplegarImagenAR" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + (arg1)->desplegarImagenAR(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_desplegarImagenFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + unsigned char *arg2 = (unsigned char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_desplegarImagenFromData",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_desplegarImagenFromData" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pui_desplegarImagenFromData" "', argument " "2"" of type '" "unsigned char *""'"); + } + arg2 = reinterpret_cast< unsigned char * >(argp2); + (arg1)->desplegarImagenFromData(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_capNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_capNext",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_capNext" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + (arg1)->capNext(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_capStart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_capStart",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_capStart" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + (arg1)->capStart(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_capStop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_capStop",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_capStop" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + (arg1)->capStop(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_capClose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_capClose",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_capClose" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + (arg1)->capClose(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_capturarImagenAR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + unsigned char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_capturarImagenAR",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_capturarImagenAR" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (unsigned char *)(arg1)->capturarImagenAR(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_capturarPyImageAR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_capturarPyImageAR",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_capturarPyImageAR" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + { + binary_data bin_data = (arg1)->capturarPyImageAR(); + int size = bin_data.size; + if(size==0){ + return Py_BuildValue(""); + } + /* para crear el array en un espacio de memoria compartida ya creado y pasado por parametro + array = (PyArrayObject *) PyArray_ContiguousFromObject(input,PyArray_UBYTE,1,1); + */ + + + PyArrayObject *array = (PyArrayObject *) PyArray_FromDims(1, &size,PyArray_UBYTE); + if (array == NULL){ + PyErr_SetString(PyExc_ValueError,"Error creando PyArray"); + return Py_BuildValue(""); + } + + //Una vez creado el array copio la info + memcpy(array->data,(unsigned char *)(bin_data.data),size); + + resultobj = (PyObject *)array; + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_obtenerImagenDebugAR(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + unsigned char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_obtenerImagenDebugAR",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_obtenerImagenDebugAR" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (unsigned char *)(arg1)->obtenerImagenDebugAR(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_initPropiedadesCalibracionSoloApuntador__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + RangosColorApuntador arg3 ; + int arg4 ; + int arg5 ; + int arg6 ; + int arg7 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + int val7 ; + int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:Pui_initPropiedadesCalibracionSoloApuntador",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + { + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_RangosColorApuntador, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "3"" of type '" "RangosColorApuntador""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "3"" of type '" "RangosColorApuntador""'"); + } else { + RangosColorApuntador * temp = reinterpret_cast< RangosColorApuntador * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + ecode7 = SWIG_AsVal_int(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "7"" of type '" "int""'"); + } + arg7 = static_cast< int >(val7); + (arg1)->initPropiedadesCalibracionSoloApuntador(arg2,arg3,arg4,arg5,arg6,arg7); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_initPropiedadesCalibracionSoloApuntador__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + int arg3 ; + int arg4 ; + int arg5 ; + int arg6 ; + int arg7 ; + int arg8 ; + int arg9 ; + int arg10 ; + int arg11 ; + int arg12 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + int val7 ; + int ecode7 = 0 ; + int val8 ; + int ecode8 = 0 ; + int val9 ; + int ecode9 = 0 ; + int val10 ; + int ecode10 = 0 ; + int val11 ; + int ecode11 = 0 ; + int val12 ; + int ecode12 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + PyObject * obj8 = 0 ; + PyObject * obj9 = 0 ; + PyObject * obj10 = 0 ; + PyObject * obj11 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOOOO:Pui_initPropiedadesCalibracionSoloApuntador",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9,&obj10,&obj11)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + ecode7 = SWIG_AsVal_int(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "7"" of type '" "int""'"); + } + arg7 = static_cast< int >(val7); + ecode8 = SWIG_AsVal_int(obj7, &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "8"" of type '" "int""'"); + } + arg8 = static_cast< int >(val8); + ecode9 = SWIG_AsVal_int(obj8, &val9); + if (!SWIG_IsOK(ecode9)) { + SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "9"" of type '" "int""'"); + } + arg9 = static_cast< int >(val9); + ecode10 = SWIG_AsVal_int(obj9, &val10); + if (!SWIG_IsOK(ecode10)) { + SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "10"" of type '" "int""'"); + } + arg10 = static_cast< int >(val10); + ecode11 = SWIG_AsVal_int(obj10, &val11); + if (!SWIG_IsOK(ecode11)) { + SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "11"" of type '" "int""'"); + } + arg11 = static_cast< int >(val11); + ecode12 = SWIG_AsVal_int(obj11, &val12); + if (!SWIG_IsOK(ecode12)) { + SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "Pui_initPropiedadesCalibracionSoloApuntador" "', argument " "12"" of type '" "int""'"); + } + arg12 = static_cast< int >(val12); + (arg1)->initPropiedadesCalibracionSoloApuntador(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_initPropiedadesCalibracionSoloApuntador(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[13]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 12); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 7) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pui, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_RangosColorApuntador, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Pui_initPropiedadesCalibracionSoloApuntador__SWIG_0(self, args); + } + } + } + } + } + } + } + } + if (argc == 12) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pui, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[8], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[9], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[10], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[11], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Pui_initPropiedadesCalibracionSoloApuntador__SWIG_1(self, args); + } + } + } + } + } + } + } + } + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Pui_initPropiedadesCalibracionSoloApuntador'.\n" + " Possible C/C++ prototypes are:\n" + " initPropiedadesCalibracionSoloApuntador(Pui *,int,RangosColorApuntador,int,int,int,int)\n" + " initPropiedadesCalibracionSoloApuntador(Pui *,int,int,int,int,int,int,int,int,int,int,int)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_aplicarNuevaMascaraCalibrador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Pui_aplicarNuevaMascaraCalibrador",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_aplicarNuevaMascaraCalibrador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_aplicarNuevaMascaraCalibrador" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pui_aplicarNuevaMascaraCalibrador" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (int)(arg1)->aplicarNuevaMascaraCalibrador(arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_aplicarMascaraCalibrador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_aplicarMascaraCalibrador",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_aplicarMascaraCalibrador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_aplicarMascaraCalibrador" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (int)(arg1)->aplicarMascaraCalibrador(arg2); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_setAchicarRadioMascaraCircular(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_setAchicarRadioMascaraCircular",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_setAchicarRadioMascaraCircular" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_setAchicarRadioMascaraCircular" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->setAchicarRadioMascaraCircular(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getAchicarRadioMascaraCircular(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getAchicarRadioMascaraCircular",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getAchicarRadioMascaraCircular" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (int)(arg1)->getAchicarRadioMascaraCircular(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getCalibrationImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + unsigned char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getCalibrationImage",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getCalibrationImage" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (unsigned char *)(arg1)->getCalibrationImage(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_tomarMuestraApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_tomarMuestraApuntador",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_tomarMuestraApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (int)(arg1)->tomarMuestraApuntador(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_calcularResultadosCalibracionApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"OOO:Pui_calcularResultadosCalibracionApuntador",&obj0,&obj1,&obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_calcularResultadosCalibracionApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_calcularResultadosCalibracionApuntador" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pui_calcularResultadosCalibracionApuntador" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + result = (int)(arg1)->calcularResultadosCalibracionApuntador(arg2,arg3); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_guardarSoloRangosColorApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + char *arg2 = (char *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_guardarSoloRangosColorApuntador",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_guardarSoloRangosColorApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pui_guardarSoloRangosColorApuntador" "', argument " "2"" of type '" "char *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + (arg1)->guardarSoloRangosColorApuntador(arg2); + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_guardarCalibracionApuntador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + float arg4 ; + int arg5 ; + int arg6 ; + int arg7 ; + int arg8 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int val3 ; + int ecode3 = 0 ; + float val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + int val7 ; + int ecode7 = 0 ; + int val8 ; + int ecode8 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:Pui_guardarCalibracionApuntador",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_guardarCalibracionApuntador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Pui_guardarCalibracionApuntador" "', argument " "2"" of type '" "char *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pui_guardarCalibracionApuntador" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_float(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pui_guardarCalibracionApuntador" "', argument " "4"" of type '" "float""'"); + } + arg4 = static_cast< float >(val4); + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Pui_guardarCalibracionApuntador" "', argument " "5"" of type '" "int""'"); + } + arg5 = static_cast< int >(val5); + ecode6 = SWIG_AsVal_int(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Pui_guardarCalibracionApuntador" "', argument " "6"" of type '" "int""'"); + } + arg6 = static_cast< int >(val6); + ecode7 = SWIG_AsVal_int(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Pui_guardarCalibracionApuntador" "', argument " "7"" of type '" "int""'"); + } + arg7 = static_cast< int >(val7); + ecode8 = SWIG_AsVal_int(obj7, &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Pui_guardarCalibracionApuntador" "', argument " "8"" of type '" "int""'"); + } + arg8 = static_cast< int >(val8); + (arg1)->guardarCalibracionApuntador(arg2,arg3,arg4,arg5,arg6,arg7,arg8); + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_setDebugCalibracion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_setDebugCalibracion",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_setDebugCalibracion" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_setDebugCalibracion" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + (arg1)->setDebugCalibracion(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_isDebugCalibracion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_isDebugCalibracion",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_isDebugCalibracion" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (bool)(arg1)->isDebugCalibracion(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getResultadosRangosColor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + RangosColorApuntador result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getResultadosRangosColor",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getResultadosRangosColor" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (arg1)->getResultadosRangosColor(); + resultobj = SWIG_NewPointerObj((new RangosColorApuntador(static_cast< const RangosColorApuntador& >(result))), SWIGTYPE_p_RangosColorApuntador, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_detectarYCalcularPosicionTodosMultiMarkers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_detectarYCalcularPosicionTodosMultiMarkers",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_detectarYCalcularPosicionTodosMultiMarkers" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (int)(arg1)->detectarYCalcularPosicionTodosMultiMarkers(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_detectarMarcadores(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_detectarMarcadores",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_detectarMarcadores" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (int)(arg1)->detectarMarcadores(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_detectarMarcadoresSimple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_detectarMarcadoresSimple",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_detectarMarcadoresSimple" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (int)(arg1)->detectarMarcadoresSimple(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getIdMarcadorSimpleDetectado(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getIdMarcadorSimpleDetectado",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getIdMarcadorSimpleDetectado" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (int)(arg1)->getIdMarcadorSimpleDetectado(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getMarcadorSimpleDetectado(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + ARCoordMarcador result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getMarcadorSimpleDetectado",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getMarcadorSimpleDetectado" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (arg1)->getMarcadorSimpleDetectado(); + resultobj = SWIG_NewPointerObj((new ARCoordMarcador(static_cast< const ARCoordMarcador& >(result))), SWIGTYPE_p_ARCoordMarcador, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getInfoMultiMarcador(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + ARCoordMarcador result; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_getInfoMultiMarcador",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getInfoMultiMarcador" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_getInfoMultiMarcador" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + result = (arg1)->getInfoMultiMarcador(arg2); + resultobj = SWIG_NewPointerObj((new ARCoordMarcador(static_cast< const ARCoordMarcador& >(result))), SWIGTYPE_p_ARCoordMarcador, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_setARCf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_setARCf",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_setARCf" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_setARCf" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + (arg1)->setARCf(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getARCf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + double result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getARCf",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getARCf" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (double)(arg1)->getARCf(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getARThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getARThreshold",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getARThreshold" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (int)(arg1)->getARThreshold(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_setARThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_setARThreshold",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_setARThreshold" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_setARThreshold" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->setARThreshold(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_initPuiConCapturaDeVideo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + PropiedadesDeteccionApuntador arg3 ; + RangosColorApuntador arg4 ; + char *arg5 = (char *) 0 ; + char *arg6 = (char *) 0 ; + char *arg7 = (char *) 0 ; + int arg8 ; + int arg9 ; + double arg10 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 ; + int res3 = 0 ; + void *argp4 ; + int res4 = 0 ; + int res5 ; + char *buf5 = 0 ; + int alloc5 = 0 ; + int res6 ; + char *buf6 = 0 ; + int alloc6 = 0 ; + int res7 ; + char *buf7 = 0 ; + int alloc7 = 0 ; + int val8 ; + int ecode8 = 0 ; + int val9 ; + int ecode9 = 0 ; + double val10 ; + int ecode10 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + PyObject * obj8 = 0 ; + PyObject * obj9 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOOO:Pui_initPuiConCapturaDeVideo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8,&obj9)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + { + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_PropiedadesDeteccionApuntador, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "3"" of type '" "PropiedadesDeteccionApuntador""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "3"" of type '" "PropiedadesDeteccionApuntador""'"); + } else { + PropiedadesDeteccionApuntador * temp = reinterpret_cast< PropiedadesDeteccionApuntador * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + { + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_RangosColorApuntador, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "4"" of type '" "RangosColorApuntador""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "4"" of type '" "RangosColorApuntador""'"); + } else { + RangosColorApuntador * temp = reinterpret_cast< RangosColorApuntador * >(argp4); + arg4 = *temp; + if (SWIG_IsNewObj(res4)) delete temp; + } + } + res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "5"" of type '" "char *""'"); + } + arg5 = reinterpret_cast< char * >(buf5); + res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "6"" of type '" "char *""'"); + } + arg6 = reinterpret_cast< char * >(buf6); + res7 = SWIG_AsCharPtrAndSize(obj6, &buf7, NULL, &alloc7); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "7"" of type '" "char *""'"); + } + arg7 = reinterpret_cast< char * >(buf7); + ecode8 = SWIG_AsVal_int(obj7, &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "8"" of type '" "int""'"); + } + arg8 = static_cast< int >(val8); + ecode9 = SWIG_AsVal_int(obj8, &val9); + if (!SWIG_IsOK(ecode9)) { + SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "9"" of type '" "int""'"); + } + arg9 = static_cast< int >(val9); + ecode10 = SWIG_AsVal_double(obj9, &val10); + if (!SWIG_IsOK(ecode10)) { + SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "10"" of type '" "double""'"); + } + arg10 = static_cast< double >(val10); + (arg1)->initPuiConCapturaDeVideo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); + resultobj = SWIG_Py_Void(); + if (alloc5 == SWIG_NEWOBJ) delete[] buf5; + if (alloc6 == SWIG_NEWOBJ) delete[] buf6; + if (alloc7 == SWIG_NEWOBJ) delete[] buf7; + return resultobj; +fail: + if (alloc5 == SWIG_NEWOBJ) delete[] buf5; + if (alloc6 == SWIG_NEWOBJ) delete[] buf6; + if (alloc7 == SWIG_NEWOBJ) delete[] buf7; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_initPuiConCapturaDeVideo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + char *arg3 = (char *) 0 ; + char *arg4 = (char *) 0 ; + char *arg5 = (char *) 0 ; + char *arg6 = (char *) 0 ; + int arg7 ; + int arg8 ; + double arg9 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + int res4 ; + char *buf4 = 0 ; + int alloc4 = 0 ; + int res5 ; + char *buf5 = 0 ; + int alloc5 = 0 ; + int res6 ; + char *buf6 = 0 ; + int alloc6 = 0 ; + int val7 ; + int ecode7 = 0 ; + int val8 ; + int ecode8 = 0 ; + double val9 ; + int ecode9 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + PyObject * obj8 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:Pui_initPuiConCapturaDeVideo",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "3"" of type '" "char *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "4"" of type '" "char *""'"); + } + arg4 = reinterpret_cast< char * >(buf4); + res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "5"" of type '" "char *""'"); + } + arg5 = reinterpret_cast< char * >(buf5); + res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "6"" of type '" "char *""'"); + } + arg6 = reinterpret_cast< char * >(buf6); + ecode7 = SWIG_AsVal_int(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "7"" of type '" "int""'"); + } + arg7 = static_cast< int >(val7); + ecode8 = SWIG_AsVal_int(obj7, &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "8"" of type '" "int""'"); + } + arg8 = static_cast< int >(val8); + ecode9 = SWIG_AsVal_double(obj8, &val9); + if (!SWIG_IsOK(ecode9)) { + SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "Pui_initPuiConCapturaDeVideo" "', argument " "9"" of type '" "double""'"); + } + arg9 = static_cast< double >(val9); + (arg1)->initPuiConCapturaDeVideo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + resultobj = SWIG_Py_Void(); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + if (alloc5 == SWIG_NEWOBJ) delete[] buf5; + if (alloc6 == SWIG_NEWOBJ) delete[] buf6; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + if (alloc5 == SWIG_NEWOBJ) delete[] buf5; + if (alloc6 == SWIG_NEWOBJ) delete[] buf6; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_initPuiConCapturaDeVideo(PyObject *self, PyObject *args) { + int argc; + PyObject *argv[11]; + int ii; + + if (!PyTuple_Check(args)) SWIG_fail; + argc = (int)PyObject_Length(args); + for (ii = 0; (ii < argc) && (ii < 10); ii++) { + argv[ii] = PyTuple_GET_ITEM(args,ii); + } + if (argc == 9) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pui, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[5], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[8], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Pui_initPuiConCapturaDeVideo__SWIG_1(self, args); + } + } + } + } + } + } + } + } + } + } + if (argc == 10) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Pui, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_PropiedadesDeteccionApuntador, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_RangosColorApuntador, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[5], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[6], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[8], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[9], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Pui_initPuiConCapturaDeVideo__SWIG_0(self, args); + } + } + } + } + } + } + } + } + } + } + } + +fail: + SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Pui_initPuiConCapturaDeVideo'.\n" + " Possible C/C++ prototypes are:\n" + " initPuiConCapturaDeVideo(Pui *,int,PropiedadesDeteccionApuntador,RangosColorApuntador,char *,char *,char *,int,int,double)\n" + " initPuiConCapturaDeVideo(Pui *,int,char *,char *,char *,char *,int,int,double)\n"); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_setDebugConImagenes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_setDebugConImagenes",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_setDebugConImagenes" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_setDebugConImagenes" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->setDebugConImagenes(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getDebugConImagenes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getDebugConImagenes",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getDebugConImagenes" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (int)(arg1)->getDebugConImagenes(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_habilitarHistorico(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + bool arg2 ; + int arg3 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OOOO:Pui_habilitarHistorico",&obj0,&obj1,&obj2,&obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_habilitarHistorico" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_habilitarHistorico" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Pui_habilitarHistorico" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Pui_habilitarHistorico" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); + (arg1)->habilitarHistorico(arg2,arg3,arg4); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_isHistoricoHabilitado(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + bool result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_isHistoricoHabilitado",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_isHistoricoHabilitado" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (bool)(arg1)->isHistoricoHabilitado(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_finish(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_finish",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_finish" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + (arg1)->finish(); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getFPSAndResetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + double result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getFPSAndResetCount",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getFPSAndResetCount" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (double)(arg1)->getFPSAndResetCount(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getFPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + double result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getFPS",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getFPS" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (double)(arg1)->getFPS(); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getModuleInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + char *result = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getModuleInfo",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getModuleInfo" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (char *)(arg1)->getModuleInfo(); + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_setDebugMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if (!PyArg_ParseTuple(args,(char *)"OO:Pui_setDebugMode",&obj0,&obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_setDebugMode" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Pui_setDebugMode" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + (arg1)->setDebugMode(arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Pui_getDebugMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + Pui *arg1 = (Pui *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + int result; + + if (!PyArg_ParseTuple(args,(char *)"O:Pui_getDebugMode",&obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Pui, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Pui_getDebugMode" "', argument " "1"" of type '" "Pui *""'"); + } + arg1 = reinterpret_cast< Pui * >(argp1); + result = (int)(arg1)->getDebugMode(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *Pui_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_Pui, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +static PyMethodDef SwigMethods[] = { + { (char *)"ARCoordMarcador_area_set", _wrap_ARCoordMarcador_area_set, METH_VARARGS, NULL}, + { (char *)"ARCoordMarcador_area_get", _wrap_ARCoordMarcador_area_get, METH_VARARGS, NULL}, + { (char *)"ARCoordMarcador_centro_set", _wrap_ARCoordMarcador_centro_set, METH_VARARGS, NULL}, + { (char *)"ARCoordMarcador_centro_get", _wrap_ARCoordMarcador_centro_get, METH_VARARGS, NULL}, + { (char *)"ARCoordMarcador_vertex_set", _wrap_ARCoordMarcador_vertex_set, METH_VARARGS, NULL}, + { (char *)"ARCoordMarcador_vertex_get", _wrap_ARCoordMarcador_vertex_get, METH_VARARGS, NULL}, + { (char *)"ARCoordMarcador_visible_set", _wrap_ARCoordMarcador_visible_set, METH_VARARGS, NULL}, + { (char *)"ARCoordMarcador_visible_get", _wrap_ARCoordMarcador_visible_get, METH_VARARGS, NULL}, + { (char *)"ARCoordMarcador_id_set", _wrap_ARCoordMarcador_id_set, METH_VARARGS, NULL}, + { (char *)"ARCoordMarcador_id_get", _wrap_ARCoordMarcador_id_get, METH_VARARGS, NULL}, + { (char *)"ARCoordMarcador_cf_set", _wrap_ARCoordMarcador_cf_set, METH_VARARGS, NULL}, + { (char *)"ARCoordMarcador_cf_get", _wrap_ARCoordMarcador_cf_get, METH_VARARGS, NULL}, + { (char *)"new_ARCoordMarcador", _wrap_new_ARCoordMarcador, METH_VARARGS, NULL}, + { (char *)"delete_ARCoordMarcador", _wrap_delete_ARCoordMarcador, METH_VARARGS, NULL}, + { (char *)"ARCoordMarcador_swigregister", ARCoordMarcador_swigregister, METH_VARARGS, NULL}, + { (char *)"Elemento_idPatt_set", _wrap_Elemento_idPatt_set, METH_VARARGS, NULL}, + { (char *)"Elemento_idPatt_get", _wrap_Elemento_idPatt_get, METH_VARARGS, NULL}, + { (char *)"Elemento_imagen_set", _wrap_Elemento_imagen_set, METH_VARARGS, NULL}, + { (char *)"Elemento_imagen_get", _wrap_Elemento_imagen_get, METH_VARARGS, NULL}, + { (char *)"Elemento_sonido_set", _wrap_Elemento_sonido_set, METH_VARARGS, NULL}, + { (char *)"Elemento_sonido_get", _wrap_Elemento_sonido_get, METH_VARARGS, NULL}, + { (char *)"Elemento_nombre_set", _wrap_Elemento_nombre_set, METH_VARARGS, NULL}, + { (char *)"Elemento_nombre_get", _wrap_Elemento_nombre_get, METH_VARARGS, NULL}, + { (char *)"Elemento_conjunto_set", _wrap_Elemento_conjunto_set, METH_VARARGS, NULL}, + { (char *)"Elemento_conjunto_get", _wrap_Elemento_conjunto_get, METH_VARARGS, NULL}, + { (char *)"Elemento_idElementoRelacionado_set", _wrap_Elemento_idElementoRelacionado_set, METH_VARARGS, NULL}, + { (char *)"Elemento_idElementoRelacionado_get", _wrap_Elemento_idElementoRelacionado_get, METH_VARARGS, NULL}, + { (char *)"Elemento_nombreRelacion_set", _wrap_Elemento_nombreRelacion_set, METH_VARARGS, NULL}, + { (char *)"Elemento_nombreRelacion_get", _wrap_Elemento_nombreRelacion_get, METH_VARARGS, NULL}, + { (char *)"Elemento_idImagenSDL_set", _wrap_Elemento_idImagenSDL_set, METH_VARARGS, NULL}, + { (char *)"Elemento_idImagenSDL_get", _wrap_Elemento_idImagenSDL_get, METH_VARARGS, NULL}, + { (char *)"new_Elemento", _wrap_new_Elemento, METH_VARARGS, NULL}, + { (char *)"delete_Elemento", _wrap_delete_Elemento, METH_VARARGS, NULL}, + { (char *)"Elemento_swigregister", Elemento_swigregister, METH_VARARGS, NULL}, + { (char *)"Historico_tope_set", _wrap_Historico_tope_set, METH_VARARGS, NULL}, + { (char *)"Historico_tope_get", _wrap_Historico_tope_get, METH_VARARGS, NULL}, + { (char *)"Historico_cantHistorico_set", _wrap_Historico_cantHistorico_set, METH_VARARGS, NULL}, + { (char *)"Historico_cantHistorico_get", _wrap_Historico_cantHistorico_get, METH_VARARGS, NULL}, + { (char *)"Historico_historicoElementos_set", _wrap_Historico_historicoElementos_set, METH_VARARGS, NULL}, + { (char *)"Historico_historicoElementos_get", _wrap_Historico_historicoElementos_get, METH_VARARGS, NULL}, + { (char *)"new_Historico", _wrap_new_Historico, METH_VARARGS, NULL}, + { (char *)"delete_Historico", _wrap_delete_Historico, METH_VARARGS, NULL}, + { (char *)"Historico_swigregister", Historico_swigregister, METH_VARARGS, NULL}, + { (char *)"RangosColorApuntador_hmin_set", _wrap_RangosColorApuntador_hmin_set, METH_VARARGS, NULL}, + { (char *)"RangosColorApuntador_hmin_get", _wrap_RangosColorApuntador_hmin_get, METH_VARARGS, NULL}, + { (char *)"RangosColorApuntador_hmax_set", _wrap_RangosColorApuntador_hmax_set, METH_VARARGS, NULL}, + { (char *)"RangosColorApuntador_hmax_get", _wrap_RangosColorApuntador_hmax_get, METH_VARARGS, NULL}, + { (char *)"RangosColorApuntador_smin_set", _wrap_RangosColorApuntador_smin_set, METH_VARARGS, NULL}, + { (char *)"RangosColorApuntador_smin_get", _wrap_RangosColorApuntador_smin_get, METH_VARARGS, NULL}, + { (char *)"RangosColorApuntador_smax_set", _wrap_RangosColorApuntador_smax_set, METH_VARARGS, NULL}, + { (char *)"RangosColorApuntador_smax_get", _wrap_RangosColorApuntador_smax_get, METH_VARARGS, NULL}, + { (char *)"RangosColorApuntador_vmin_set", _wrap_RangosColorApuntador_vmin_set, METH_VARARGS, NULL}, + { (char *)"RangosColorApuntador_vmin_get", _wrap_RangosColorApuntador_vmin_get, METH_VARARGS, NULL}, + { (char *)"RangosColorApuntador_vmax_set", _wrap_RangosColorApuntador_vmax_set, METH_VARARGS, NULL}, + { (char *)"RangosColorApuntador_vmax_get", _wrap_RangosColorApuntador_vmax_get, METH_VARARGS, NULL}, + { (char *)"new_RangosColorApuntador", _wrap_new_RangosColorApuntador, METH_VARARGS, NULL}, + { (char *)"delete_RangosColorApuntador", _wrap_delete_RangosColorApuntador, METH_VARARGS, NULL}, + { (char *)"RangosColorApuntador_swigregister", RangosColorApuntador_swigregister, METH_VARARGS, NULL}, + { (char *)"ResultadosCalibracion_areas_minimas_set", _wrap_ResultadosCalibracion_areas_minimas_set, METH_VARARGS, NULL}, + { (char *)"ResultadosCalibracion_areas_minimas_get", _wrap_ResultadosCalibracion_areas_minimas_get, METH_VARARGS, NULL}, + { (char *)"ResultadosCalibracion_areas_maximas_set", _wrap_ResultadosCalibracion_areas_maximas_set, METH_VARARGS, NULL}, + { (char *)"ResultadosCalibracion_areas_maximas_get", _wrap_ResultadosCalibracion_areas_maximas_get, METH_VARARGS, NULL}, + { (char *)"ResultadosCalibracion_relaciones_promedio_set", _wrap_ResultadosCalibracion_relaciones_promedio_set, METH_VARARGS, NULL}, + { (char *)"ResultadosCalibracion_relaciones_promedio_get", _wrap_ResultadosCalibracion_relaciones_promedio_get, METH_VARARGS, NULL}, + { (char *)"new_ResultadosCalibracion", _wrap_new_ResultadosCalibracion, METH_VARARGS, NULL}, + { (char *)"delete_ResultadosCalibracion", _wrap_delete_ResultadosCalibracion, METH_VARARGS, NULL}, + { (char *)"ResultadosCalibracion_swigregister", ResultadosCalibracion_swigregister, METH_VARARGS, NULL}, + { (char *)"CoordApuntador_area_set", _wrap_CoordApuntador_area_set, METH_VARARGS, NULL}, + { (char *)"CoordApuntador_area_get", _wrap_CoordApuntador_area_get, METH_VARARGS, NULL}, + { (char *)"CoordApuntador_centro_set", _wrap_CoordApuntador_centro_set, METH_VARARGS, NULL}, + { (char *)"CoordApuntador_centro_get", _wrap_CoordApuntador_centro_get, METH_VARARGS, NULL}, + { (char *)"new_CoordApuntador", _wrap_new_CoordApuntador, METH_VARARGS, NULL}, + { (char *)"delete_CoordApuntador", _wrap_delete_CoordApuntador, METH_VARARGS, NULL}, + { (char *)"CoordApuntador_swigregister", CoordApuntador_swigregister, METH_VARARGS, NULL}, + { (char *)"Pui_insert", _wrap_Pui_insert, METH_VARARGS, NULL}, + { (char *)"Pui_out", _wrap_Pui_out, METH_VARARGS, NULL}, + { (char *)"new_Pui", _wrap_new_Pui, METH_VARARGS, NULL}, + { (char *)"delete_Pui", _wrap_delete_Pui, METH_VARARGS, NULL}, + { (char *)"Pui_leerConfiguracionObjetosPUI", _wrap_Pui_leerConfiguracionObjetosPUI, METH_VARARGS, NULL}, + { (char *)"Pui_leerPatternsModoSimple", _wrap_Pui_leerPatternsModoSimple, METH_VARARGS, NULL}, + { (char *)"Pui_imprimirPropiedadesObjetosPUI", _wrap_Pui_imprimirPropiedadesObjetosPUI, METH_VARARGS, NULL}, + { (char *)"Pui_getNombreObjetoPUI", _wrap_Pui_getNombreObjetoPUI, METH_VARARGS, NULL}, + { (char *)"Pui_getSonidoObjetoPUI", _wrap_Pui_getSonidoObjetoPUI, METH_VARARGS, NULL}, + { (char *)"Pui_getImagenObjetoPUI", _wrap_Pui_getImagenObjetoPUI, METH_VARARGS, NULL}, + { (char *)"Pui_getSonidoError", _wrap_Pui_getSonidoError, METH_VARARGS, NULL}, + { (char *)"Pui_getSonidoOk", _wrap_Pui_getSonidoOk, METH_VARARGS, NULL}, + { (char *)"Pui_esRelacionCorrecta", _wrap_Pui_esRelacionCorrecta, METH_VARARGS, NULL}, + { (char *)"Pui_getConjuntoObjetoPui", _wrap_Pui_getConjuntoObjetoPui, METH_VARARGS, NULL}, + { (char *)"Pui_getIdElementoRelacionado", _wrap_Pui_getIdElementoRelacionado, METH_VARARGS, NULL}, + { (char *)"Pui_getNombreRelacionObjetoPUI", _wrap_Pui_getNombreRelacionObjetoPUI, METH_VARARGS, NULL}, + { (char *)"Pui_detectarSeleccion", _wrap_Pui_detectarSeleccion, METH_VARARGS, NULL}, + { (char *)"Pui_initDeteccionApuntador", _wrap_Pui_initDeteccionApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_getPropiedadesDeteccionApuntador", _wrap_Pui_getPropiedadesDeteccionApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_setPropiedadesDeteccionApuntador", _wrap_Pui_setPropiedadesDeteccionApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_getPropiedadesColorApuntador", _wrap_Pui_getPropiedadesColorApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_setPropiedadesColorApuntador", _wrap_Pui_setPropiedadesColorApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_setHminApuntador", _wrap_Pui_setHminApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_getHminApuntador", _wrap_Pui_getHminApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_setHmaxApuntador", _wrap_Pui_setHmaxApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_getHmaxApuntador", _wrap_Pui_getHmaxApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_setSminApuntador", _wrap_Pui_setSminApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_getSminApuntador", _wrap_Pui_getSminApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_setSmaxApuntador", _wrap_Pui_setSmaxApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_getSmaxApuntador", _wrap_Pui_getSmaxApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_setVminApuntador", _wrap_Pui_setVminApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_getVminApuntador", _wrap_Pui_getVminApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_setVmaxApuntador", _wrap_Pui_setVmaxApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_getVmaxApuntador", _wrap_Pui_getVmaxApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_procesarDatosCalibracion", _wrap_Pui_procesarDatosCalibracion, METH_VARARGS, NULL}, + { (char *)"Pui_guardarDatosCalibracion", _wrap_Pui_guardarDatosCalibracion, METH_VARARGS, NULL}, + { (char *)"Pui_initPropiedadesCalibracion", _wrap_Pui_initPropiedadesCalibracion, METH_VARARGS, NULL}, + { (char *)"Pui_leerConfiguracionCalibracion", _wrap_Pui_leerConfiguracionCalibracion, METH_VARARGS, NULL}, + { (char *)"Pui_calibrarThreshold", _wrap_Pui_calibrarThreshold, METH_VARARGS, NULL}, + { (char *)"Pui_setBrillo", _wrap_Pui_setBrillo, METH_VARARGS, NULL}, + { (char *)"Pui_setAutoWhiteBalance", _wrap_Pui_setAutoWhiteBalance, METH_VARARGS, NULL}, + { (char *)"Pui_setAutoGain", _wrap_Pui_setAutoGain, METH_VARARGS, NULL}, + { (char *)"Pui_setHorizontalFlip", _wrap_Pui_setHorizontalFlip, METH_VARARGS, NULL}, + { (char *)"Pui_abrirVentanaGrafica", _wrap_Pui_abrirVentanaGrafica, METH_VARARGS, NULL}, + { (char *)"Pui_cerrarVentanaGrafica", _wrap_Pui_cerrarVentanaGrafica, METH_VARARGS, NULL}, + { (char *)"Pui_desplegarImagenAR", _wrap_Pui_desplegarImagenAR, METH_VARARGS, NULL}, + { (char *)"Pui_desplegarImagenFromData", _wrap_Pui_desplegarImagenFromData, METH_VARARGS, NULL}, + { (char *)"Pui_capNext", _wrap_Pui_capNext, METH_VARARGS, NULL}, + { (char *)"Pui_capStart", _wrap_Pui_capStart, METH_VARARGS, NULL}, + { (char *)"Pui_capStop", _wrap_Pui_capStop, METH_VARARGS, NULL}, + { (char *)"Pui_capClose", _wrap_Pui_capClose, METH_VARARGS, NULL}, + { (char *)"Pui_capturarImagenAR", _wrap_Pui_capturarImagenAR, METH_VARARGS, NULL}, + { (char *)"Pui_capturarPyImageAR", _wrap_Pui_capturarPyImageAR, METH_VARARGS, NULL}, + { (char *)"Pui_obtenerImagenDebugAR", _wrap_Pui_obtenerImagenDebugAR, METH_VARARGS, NULL}, + { (char *)"Pui_initPropiedadesCalibracionSoloApuntador", _wrap_Pui_initPropiedadesCalibracionSoloApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_aplicarNuevaMascaraCalibrador", _wrap_Pui_aplicarNuevaMascaraCalibrador, METH_VARARGS, NULL}, + { (char *)"Pui_aplicarMascaraCalibrador", _wrap_Pui_aplicarMascaraCalibrador, METH_VARARGS, NULL}, + { (char *)"Pui_setAchicarRadioMascaraCircular", _wrap_Pui_setAchicarRadioMascaraCircular, METH_VARARGS, NULL}, + { (char *)"Pui_getAchicarRadioMascaraCircular", _wrap_Pui_getAchicarRadioMascaraCircular, METH_VARARGS, NULL}, + { (char *)"Pui_getCalibrationImage", _wrap_Pui_getCalibrationImage, METH_VARARGS, NULL}, + { (char *)"Pui_tomarMuestraApuntador", _wrap_Pui_tomarMuestraApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_calcularResultadosCalibracionApuntador", _wrap_Pui_calcularResultadosCalibracionApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_guardarSoloRangosColorApuntador", _wrap_Pui_guardarSoloRangosColorApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_guardarCalibracionApuntador", _wrap_Pui_guardarCalibracionApuntador, METH_VARARGS, NULL}, + { (char *)"Pui_setDebugCalibracion", _wrap_Pui_setDebugCalibracion, METH_VARARGS, NULL}, + { (char *)"Pui_isDebugCalibracion", _wrap_Pui_isDebugCalibracion, METH_VARARGS, NULL}, + { (char *)"Pui_getResultadosRangosColor", _wrap_Pui_getResultadosRangosColor, METH_VARARGS, NULL}, + { (char *)"Pui_detectarYCalcularPosicionTodosMultiMarkers", _wrap_Pui_detectarYCalcularPosicionTodosMultiMarkers, METH_VARARGS, NULL}, + { (char *)"Pui_detectarMarcadores", _wrap_Pui_detectarMarcadores, METH_VARARGS, NULL}, + { (char *)"Pui_detectarMarcadoresSimple", _wrap_Pui_detectarMarcadoresSimple, METH_VARARGS, NULL}, + { (char *)"Pui_getIdMarcadorSimpleDetectado", _wrap_Pui_getIdMarcadorSimpleDetectado, METH_VARARGS, NULL}, + { (char *)"Pui_getMarcadorSimpleDetectado", _wrap_Pui_getMarcadorSimpleDetectado, METH_VARARGS, NULL}, + { (char *)"Pui_getInfoMultiMarcador", _wrap_Pui_getInfoMultiMarcador, METH_VARARGS, NULL}, + { (char *)"Pui_setARCf", _wrap_Pui_setARCf, METH_VARARGS, NULL}, + { (char *)"Pui_getARCf", _wrap_Pui_getARCf, METH_VARARGS, NULL}, + { (char *)"Pui_getARThreshold", _wrap_Pui_getARThreshold, METH_VARARGS, NULL}, + { (char *)"Pui_setARThreshold", _wrap_Pui_setARThreshold, METH_VARARGS, NULL}, + { (char *)"Pui_initPuiConCapturaDeVideo", _wrap_Pui_initPuiConCapturaDeVideo, METH_VARARGS, NULL}, + { (char *)"Pui_setDebugConImagenes", _wrap_Pui_setDebugConImagenes, METH_VARARGS, NULL}, + { (char *)"Pui_getDebugConImagenes", _wrap_Pui_getDebugConImagenes, METH_VARARGS, NULL}, + { (char *)"Pui_habilitarHistorico", _wrap_Pui_habilitarHistorico, METH_VARARGS, NULL}, + { (char *)"Pui_isHistoricoHabilitado", _wrap_Pui_isHistoricoHabilitado, METH_VARARGS, NULL}, + { (char *)"Pui_finish", _wrap_Pui_finish, METH_VARARGS, NULL}, + { (char *)"Pui_getFPSAndResetCount", _wrap_Pui_getFPSAndResetCount, METH_VARARGS, NULL}, + { (char *)"Pui_getFPS", _wrap_Pui_getFPS, METH_VARARGS, NULL}, + { (char *)"Pui_getModuleInfo", _wrap_Pui_getModuleInfo, METH_VARARGS, NULL}, + { (char *)"Pui_setDebugMode", _wrap_Pui_setDebugMode, METH_VARARGS, NULL}, + { (char *)"Pui_getDebugMode", _wrap_Pui_getDebugMode, METH_VARARGS, NULL}, + { (char *)"Pui_swigregister", Pui_swigregister, METH_VARARGS, NULL}, + { NULL, NULL, 0, NULL } +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static swig_type_info _swigt__p_ARCoordMarcador = {"_p_ARCoordMarcador", "ARCoordMarcador *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_CoordApuntador = {"_p_CoordApuntador", "CoordApuntador *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_Elemento = {"_p_Elemento", "Elemento *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_Historico = {"_p_Historico", "Historico *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_PropiedadesDeteccionApuntador = {"_p_PropiedadesDeteccionApuntador", "PropiedadesDeteccionApuntador *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_Pui = {"_p_Pui", "Pui *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RangosColorApuntador = {"_p_RangosColorApuntador", "RangosColorApuntador *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ResultadosCalibracion = {"_p_ResultadosCalibracion", "ResultadosCalibracion *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_a_2__double = {"_p_a_2__double", "double (*)[2]", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *", 0, 0, (void*)0, 0}; + +static swig_type_info *swig_type_initial[] = { + &_swigt__p_ARCoordMarcador, + &_swigt__p_CoordApuntador, + &_swigt__p_Elemento, + &_swigt__p_Historico, + &_swigt__p_PropiedadesDeteccionApuntador, + &_swigt__p_Pui, + &_swigt__p_RangosColorApuntador, + &_swigt__p_ResultadosCalibracion, + &_swigt__p_a_2__double, + &_swigt__p_char, + &_swigt__p_double, + &_swigt__p_int, + &_swigt__p_p_char, + &_swigt__p_unsigned_char, +}; + +static swig_cast_info _swigc__p_ARCoordMarcador[] = { {&_swigt__p_ARCoordMarcador, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_CoordApuntador[] = { {&_swigt__p_CoordApuntador, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_Elemento[] = { {&_swigt__p_Elemento, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_Historico[] = { {&_swigt__p_Historico, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_PropiedadesDeteccionApuntador[] = { {&_swigt__p_PropiedadesDeteccionApuntador, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_Pui[] = { {&_swigt__p_Pui, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RangosColorApuntador[] = { {&_swigt__p_RangosColorApuntador, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ResultadosCalibracion[] = { {&_swigt__p_ResultadosCalibracion, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_a_2__double[] = { {&_swigt__p_a_2__double, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}}; + +static swig_cast_info *swig_cast_initial[] = { + _swigc__p_ARCoordMarcador, + _swigc__p_CoordApuntador, + _swigc__p_Elemento, + _swigc__p_Historico, + _swigc__p_PropiedadesDeteccionApuntador, + _swigc__p_Pui, + _swigc__p_RangosColorApuntador, + _swigc__p_ResultadosCalibracion, + _swigc__p_a_2__double, + _swigc__p_char, + _swigc__p_double, + _swigc__p_int, + _swigc__p_p_char, + _swigc__p_unsigned_char, +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + +static swig_const_info swig_const_table[] = { +{0, 0, 0, 0.0, 0, 0}}; + +#ifdef __cplusplus +} +#endif +/* ----------------------------------------------------------------------------- + * Type initialization: + * This problem is tough by the requirement that no dynamic + * memory is used. Also, since swig_type_info structures store pointers to + * swig_cast_info structures and swig_cast_info structures store pointers back + * to swig_type_info structures, we need some lookup code at initialization. + * The idea is that swig generates all the structures that are needed. + * The runtime then collects these partially filled structures. + * The SWIG_InitializeModule function takes these initial arrays out of + * swig_module, and does all the lookup, filling in the swig_module.types + * array with the correct data and linking the correct swig_cast_info + * structures together. + * + * The generated swig_type_info structures are assigned staticly to an initial + * array. We just loop through that array, and handle each type individually. + * First we lookup if this type has been already loaded, and if so, use the + * loaded structure instead of the generated one. Then we have to fill in the + * cast linked list. The cast data is initially stored in something like a + * two-dimensional array. Each row corresponds to a type (there are the same + * number of rows as there are in the swig_type_initial array). Each entry in + * a column is one of the swig_cast_info structures for that type. + * The cast_initial array is actually an array of arrays, because each row has + * a variable number of columns. So to actually build the cast linked list, + * we find the array of casts associated with the type, and loop through it + * adding the casts to the list. The one last trick we need to do is making + * sure the type pointer in the swig_cast_info struct is correct. + * + * First off, we lookup the cast->type name to see if it is already loaded. + * There are three cases to handle: + * 1) If the cast->type has already been loaded AND the type we are adding + * casting info to has not been loaded (it is in this module), THEN we + * replace the cast->type pointer with the type pointer that has already + * been loaded. + * 2) If BOTH types (the one we are adding casting info to, and the + * cast->type) are loaded, THEN the cast info has already been loaded by + * the previous module so we just ignore it. + * 3) Finally, if cast->type has not already been loaded, then we add that + * swig_cast_info to the linked list (because the cast->type) pointer will + * be correct. + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#if 0 +} /* c-mode */ +#endif +#endif + +#if 0 +#define SWIGRUNTIME_DEBUG +#endif + + +SWIGRUNTIME void +SWIG_InitializeModule(void *clientdata) { + size_t i; + swig_module_info *module_head, *iter; + int found, init; + + clientdata = clientdata; + + /* check to see if the circular list has been setup, if not, set it up */ + if (swig_module.next==0) { + /* Initialize the swig_module */ + swig_module.type_initial = swig_type_initial; + swig_module.cast_initial = swig_cast_initial; + swig_module.next = &swig_module; + init = 1; + } else { + init = 0; + } + + /* Try and load any already created modules */ + module_head = SWIG_GetModule(clientdata); + if (!module_head) { + /* This is the first module loaded for this interpreter */ + /* so set the swig module into the interpreter */ + SWIG_SetModule(clientdata, &swig_module); + module_head = &swig_module; + } else { + /* the interpreter has loaded a SWIG module, but has it loaded this one? */ + found=0; + iter=module_head; + do { + if (iter==&swig_module) { + found=1; + break; + } + iter=iter->next; + } while (iter!= module_head); + + /* if the is found in the list, then all is done and we may leave */ + if (found) return; + /* otherwise we must add out module into the list */ + swig_module.next = module_head->next; + module_head->next = &swig_module; + } + + /* When multiple interpeters are used, a module could have already been initialized in + a different interpreter, but not yet have a pointer in this interpreter. + In this case, we do not want to continue adding types... everything should be + set up already */ + if (init == 0) return; + + /* Now work on filling in swig_module.types */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: size %d\n", swig_module.size); +#endif + for (i = 0; i < swig_module.size; ++i) { + swig_type_info *type = 0; + swig_type_info *ret; + swig_cast_info *cast; + +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); +#endif + + /* if there is another module already loaded */ + if (swig_module.next != &swig_module) { + type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); + } + if (type) { + /* Overwrite clientdata field */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found type %s\n", type->name); +#endif + if (swig_module.type_initial[i]->clientdata) { + type->clientdata = swig_module.type_initial[i]->clientdata; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); +#endif + } + } else { + type = swig_module.type_initial[i]; + } + + /* Insert casting types */ + cast = swig_module.cast_initial[i]; + while (cast->type) { + /* Don't need to add information already in the list */ + ret = 0; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); +#endif + if (swig_module.next != &swig_module) { + ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); +#ifdef SWIGRUNTIME_DEBUG + if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); +#endif + } + if (ret) { + if (type == swig_module.type_initial[i]) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: skip old type %s\n", ret->name); +#endif + cast->type = ret; + ret = 0; + } else { + /* Check for casting already in the list */ + swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); +#ifdef SWIGRUNTIME_DEBUG + if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); +#endif + if (!ocast) ret = 0; + } + } + + if (!ret) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); +#endif + if (type->cast) { + type->cast->prev = cast; + cast->next = type->cast; + } + type->cast = cast; + } + cast++; + } + /* Set entry in modules->types array equal to the type */ + swig_module.types[i] = type; + } + swig_module.types[i] = 0; + +#ifdef SWIGRUNTIME_DEBUG + printf("**** SWIG_InitializeModule: Cast List ******\n"); + for (i = 0; i < swig_module.size; ++i) { + int j = 0; + swig_cast_info *cast = swig_module.cast_initial[i]; + printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); + while (cast->type) { + printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); + cast++; + ++j; + } + printf("---- Total casts: %d\n",j); + } + printf("**** SWIG_InitializeModule: Cast List ******\n"); +#endif +} + +/* This function will propagate the clientdata field of type to +* any new swig_type_info structures that have been added into the list +* of equivalent types. It is like calling +* SWIG_TypeClientData(type, clientdata) a second time. +*/ +SWIGRUNTIME void +SWIG_PropagateClientData(void) { + size_t i; + swig_cast_info *equiv; + static int init_run = 0; + + if (init_run) return; + init_run = 1; + + for (i = 0; i < swig_module.size; i++) { + if (swig_module.types[i]->clientdata) { + equiv = swig_module.types[i]->cast; + while (equiv) { + if (!equiv->converter) { + if (equiv->type && !equiv->type->clientdata) + SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); + } + equiv = equiv->next; + } + } + } +} + +#ifdef __cplusplus +#if 0 +{ + /* c-mode */ +#endif +} +#endif + + + +#ifdef __cplusplus +extern "C" { +#endif + + /* Python-specific SWIG API */ +#define SWIG_newvarlink() SWIG_Python_newvarlink() +#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) +#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) + + /* ----------------------------------------------------------------------------- + * global variable support code. + * ----------------------------------------------------------------------------- */ + + typedef struct swig_globalvar { + char *name; /* Name of global variable */ + PyObject *(*get_attr)(void); /* Return the current value */ + int (*set_attr)(PyObject *); /* Set the value */ + struct swig_globalvar *next; + } swig_globalvar; + + typedef struct swig_varlinkobject { + PyObject_HEAD + swig_globalvar *vars; + } swig_varlinkobject; + + SWIGINTERN PyObject * + swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { + return PyString_FromString("<Swig global variables>"); + } + + SWIGINTERN PyObject * + swig_varlink_str(swig_varlinkobject *v) { + PyObject *str = PyString_FromString("("); + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + PyString_ConcatAndDel(&str,PyString_FromString(var->name)); + if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); + } + PyString_ConcatAndDel(&str,PyString_FromString(")")); + return str; + } + + SWIGINTERN int + swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) { + PyObject *str = swig_varlink_str(v); + fprintf(fp,"Swig global variables "); + fprintf(fp,"%s\n", PyString_AsString(str)); + Py_DECREF(str); + return 0; + } + + SWIGINTERN void + swig_varlink_dealloc(swig_varlinkobject *v) { + swig_globalvar *var = v->vars; + while (var) { + swig_globalvar *n = var->next; + free(var->name); + free(var); + var = n; + } + } + + SWIGINTERN PyObject * + swig_varlink_getattr(swig_varlinkobject *v, char *n) { + PyObject *res = NULL; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->get_attr)(); + break; + } + var = var->next; + } + if (res == NULL && !PyErr_Occurred()) { + PyErr_SetString(PyExc_NameError,"Unknown C global variable"); + } + return res; + } + + SWIGINTERN int + swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { + int res = 1; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->set_attr)(p); + break; + } + var = var->next; + } + if (res == 1 && !PyErr_Occurred()) { + PyErr_SetString(PyExc_NameError,"Unknown C global variable"); + } + return res; + } + + SWIGINTERN PyTypeObject* + swig_varlink_type(void) { + static char varlink__doc__[] = "Swig var link object"; + static PyTypeObject varlink_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp + = { + PyObject_HEAD_INIT(NULL) + 0, /* Number of items in variable part (ob_size) */ + (char *)"swigvarlink", /* Type name (tp_name) */ + sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */ + 0, /* Itemsize (tp_itemsize) */ + (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */ + (printfunc) swig_varlink_print, /* Print (tp_print) */ + (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */ + (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */ + 0, /* tp_compare */ + (reprfunc) swig_varlink_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + (reprfunc)swig_varlink_str, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + 0, /* tp_flags */ + varlink__doc__, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ +#if PY_VERSION_HEX >= 0x02020000 + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ +#endif +#if PY_VERSION_HEX >= 0x02030000 + 0, /* tp_del */ +#endif +#ifdef COUNT_ALLOCS + 0,0,0,0 /* tp_alloc -> tp_next */ +#endif + }; + varlink_type = tmp; + varlink_type.ob_type = &PyType_Type; + type_init = 1; + } + return &varlink_type; + } + + /* Create a variable linking object for use later */ + SWIGINTERN PyObject * + SWIG_Python_newvarlink(void) { + swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); + if (result) { + result->vars = 0; + } + return ((PyObject*) result); + } + + SWIGINTERN void + SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { + swig_varlinkobject *v = (swig_varlinkobject *) p; + swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); + if (gv) { + size_t size = strlen(name)+1; + gv->name = (char *)malloc(size); + if (gv->name) { + strncpy(gv->name,name,size); + gv->get_attr = get_attr; + gv->set_attr = set_attr; + gv->next = v->vars; + } + } + v->vars = gv; + } + + SWIGINTERN PyObject * + SWIG_globals(void) { + static PyObject *_SWIG_globals = 0; + if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink(); + return _SWIG_globals; + } + + /* ----------------------------------------------------------------------------- + * constants/methods manipulation + * ----------------------------------------------------------------------------- */ + + /* Install Constants */ + SWIGINTERN void + SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { + PyObject *obj = 0; + size_t i; + for (i = 0; constants[i].type; ++i) { + switch(constants[i].type) { + case SWIG_PY_POINTER: + obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); + break; + case SWIG_PY_BINARY: + obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); + break; + default: + obj = 0; + break; + } + if (obj) { + PyDict_SetItemString(d, constants[i].name, obj); + Py_DECREF(obj); + } + } + } + + /* -----------------------------------------------------------------------------*/ + /* Fix SwigMethods to carry the callback ptrs when needed */ + /* -----------------------------------------------------------------------------*/ + + SWIGINTERN void + SWIG_Python_FixMethods(PyMethodDef *methods, + swig_const_info *const_table, + swig_type_info **types, + swig_type_info **types_initial) { + size_t i; + for (i = 0; methods[i].ml_name; ++i) { + const char *c = methods[i].ml_doc; + if (c && (c = strstr(c, "swig_ptr: "))) { + int j; + swig_const_info *ci = 0; + const char *name = c + 10; + for (j = 0; const_table[j].type; ++j) { + if (strncmp(const_table[j].name, name, + strlen(const_table[j].name)) == 0) { + ci = &(const_table[j]); + break; + } + } + if (ci) { + size_t shift = (ci->ptype) - types; + swig_type_info *ty = types_initial[shift]; + size_t ldoc = (c - methods[i].ml_doc); + size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; + char *ndoc = (char*)malloc(ldoc + lptr + 10); + if (ndoc) { + char *buff = ndoc; + void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; + if (ptr) { + strncpy(buff, methods[i].ml_doc, ldoc); + buff += ldoc; + strncpy(buff, "swig_ptr: ", 10); + buff += 10; + SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); + methods[i].ml_doc = ndoc; + } + } + } + } + } + } + +#ifdef __cplusplus +} +#endif + +/* -----------------------------------------------------------------------------* + * Partial Init method + * -----------------------------------------------------------------------------*/ + +#ifdef __cplusplus +extern "C" +#endif +SWIGEXPORT void SWIG_init(void) { + PyObject *m, *d; + + /* Fix SwigMethods to carry the callback ptrs when needed */ + SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); + + m = Py_InitModule((char *) SWIG_name, SwigMethods); + d = PyModule_GetDict(m); + + SWIG_InitializeModule(0); + SWIG_InstallConstants(d,swig_const_table); + + + + import_array(); /* load the Numeric PyCObjects */ + + SWIG_Python_SetConstant(d, "FORMA_APUNTADOR_CIRCULO",SWIG_From_int(static_cast< int >(1))); + SWIG_Python_SetConstant(d, "FORMA_APUNTADOR_RECTANGULAR",SWIG_From_int(static_cast< int >(2))); + SWIG_Python_SetConstant(d, "FORMA_APUNTADOR_MANO",SWIG_From_int(static_cast< int >(3))); + SWIG_Python_SetConstant(d, "ERROR_DETECTANDO_MARCADORES",SWIG_From_int(static_cast< int >(4))); + SWIG_Python_SetConstant(d, "ERROR_CALCULANDO_MATRIZ_TRANSFORMACION",SWIG_From_int(static_cast< int >(5))); + SWIG_Python_SetConstant(d, "ERROR_NINGUN_MARCADOR_DETECTADO",SWIG_From_int(static_cast< int >(6))); + SWIG_Python_SetConstant(d, "ERROR_IMAGEN_NULL",SWIG_From_int(static_cast< int >(7))); + SWIG_Python_SetConstant(d, "DETECCION_CORRECTA",SWIG_From_int(static_cast< int >(8))); + SWIG_Python_SetConstant(d, "MASCARA_APLICADA",SWIG_From_int(static_cast< int >(9))); + SWIG_Python_SetConstant(d, "MASCARA_NO_APLICADA",SWIG_From_int(static_cast< int >(10))); + SWIG_Python_SetConstant(d, "TIPO_MASCARA_BINARIA",SWIG_From_int(static_cast< int >(11))); + SWIG_Python_SetConstant(d, "TIPO_MASCARA_ATENUANTE",SWIG_From_int(static_cast< int >(12))); + SWIG_Python_SetConstant(d, "ERROR_TOMAR_MUESTRA_FORMA_NO_IMPLEMENTADA",SWIG_From_int(static_cast< int >(13))); + SWIG_Python_SetConstant(d, "ERROR_TOMAR_MUESTRA_OK",SWIG_From_int(static_cast< int >(14))); + SWIG_Python_SetConstant(d, "OFFSET_ROI",SWIG_From_int(static_cast< int >(5))); + SWIG_Python_SetConstant(d, "MIN_AREA_WIDTH_HEIGHT",SWIG_From_int(static_cast< int >(5))); + SWIG_Python_SetConstant(d, "MIN_CF_MARKER_DETECT",SWIG_From_double(static_cast< double >(0.6))); + SWIG_Python_SetConstant(d, "MODO_MULTI_MARKERS",SWIG_From_int(static_cast< int >(15))); + SWIG_Python_SetConstant(d, "MODO_SIMPLE",SWIG_From_int(static_cast< int >(16))); + SWIG_Python_SetConstant(d, "MODO_MULTI_MARKERS_CALIBRADOR",SWIG_From_int(static_cast< int >(17))); + SWIG_Python_SetConstant(d, "Pui_FAST_SPEED_LOOP",SWIG_From_int(static_cast< int >(Pui::FAST_SPEED_LOOP))); + SWIG_Python_SetConstant(d, "Pui_NORMAL_SPEED_LOOP",SWIG_From_int(static_cast< int >(Pui::NORMAL_SPEED_LOOP))); + SWIG_Python_SetConstant(d, "Pui_FAST_SPEED_LOOP_MULTIPLIER",SWIG_From_double(static_cast< double >(Pui::FAST_SPEED_LOOP_MULTIPLIER))); + SWIG_Python_SetConstant(d, "Pui_NORMAL_SPEED_LOOP_MULTIPLIER",SWIG_From_double(static_cast< double >(Pui::NORMAL_SPEED_LOOP_MULTIPLIER))); +} + |