Mensajes

Hola buenas noches, molesto con este post para ver si puedo recibir respuesta de alguien que sepa. Tengo un nokia c2.01 segun averigue pertenece a la serie S40 y tenia dos dudas importante.

1) Me dijeron que nokia nunca se pudo liberar... fui a un local claro de mi ciudad y esa es la respuesta que me dieron al preguntar sobre la liberacion del telefono.

2) Es posible conectar este telefono a la pc por usb y usar su camara como camara web?? estuve averiguando e instalando varios programas pero ninguna funciono, tambien lei por ahi que con los s40 no se puede que solo se puede desde los s60 para adelante, eso es cierto?

Este es el telefono:

http://www.smart-gsm.com/moviles/nokia-c2-01


Gracias y saludos.

Hola NEBIRE, una vez mas te doy gracias por la explicacion y pido disculpas por el tiempo de respuesta, es que he estado teniendo algunas complicaciones y poco tiempo, ademas mi codigo es un lio.

Asi que voy a empezar de nuevo todo el proyecto desde cero, y voy a aplicar lo que me dijiste que haga, puntos centrales, cuadrantes, promesas, cantidad minima de picos, etc.

Cuando tenga mi codigo hecho lo publicare aqui, por ahora las ideas quedaron claras, saludos,

PD: voy a revisar la wikipedia apara ver tus explicaciones, hasta la proxima. (Y)

Hola todos hago este post por que tengo una idea y no se por donde empezar para afrontarla.
Resulta que tengo un juego que tiene una consola, y en esa consola se pueden insertar los comandos del juego, existe un comando que devuelve la posicion x,y,z del jugador, yo necesitaria extraer ese dato desde el juego hacia windows para poder trabajar con esos datos, pero no tengo idea de como hacerlo, lo unico que se me ocurre es que el juego se carga en la RAM entonces las variables que manejan esos datos tienen que estar en alguna parte de la ram pero no tengo ni la menor idea de como entrar a la ram y sacar esos datos, tampoco se si lo que tendria que hacer es eso, ni tampoco sie si lo que pregunto es algo muuuuy avanzado o algo medianamente simple. En caso de que alguien sepa algo del tema, ¿que nombre recibe lo que quiero hacer?, ¿es posible?. Gracias Saludos.

Hola NEBIRE traigo aqui algunas dudas y un poco de codigo para ver si voy bien encaminado, cualquier punto de vista y/o observaciones constructivas seran tenidas en cuentas.

Con respecto al centro de cada cuadrante ya me quedo bien claro como debe ser.
Al crear las lineas del punto central tomare la distancia x que hay entre ambos puntos salientes, eso me indicara que distancia recorrera como maximo el bucle interno del scanner horizontal, esto se cumple solo en la primera fila ya que la linea esta inclinada.


Con respecto al "scanner horizontal" lo hare desde fuera hacia dentro. Cuando encuentre un pixel negro entonces la siguiente linea llegara como maximo hasta esa posicion y agregara el pixel a un array.

teniendo en cuenta la siguiente imagen:



Esto seria el scanner horizontal en el cuadrante cuatro (anti reloj)

Se puede decir que el "scanner" horizontal no me detectara el punto mas saliente de cada pico, sino que me detectara un conjunto de posibles puntos salientes, en ese conjunto de puntos esta incluido el punto saliente que estoy buscando
Por ejemplo en la imagen cada cuadrado amarillo es un punto detectado por el scanner entonces cada punto amarillo sera agregado al arraylist "posiblesPuntosSalientes" luego queda ver cual de todos esos puntos son los que busco (en la imagen son solo 2 puntos los que busco ya que son dos picos pero en el array de posibles puntos tendre: 14 puntos, para saber cual es el que busco entonces calculo el angulo en esos catorce puntos tomando el ultimo punto del cuadrante como punto central y el posible punto saliente que mas angulo me dé será el más saliente de todos, eso me lleva a decir tambien que los angulos que luego usare para comparar no se calcularan con cada punto saliente sino que se calculara con cada posible punto saliente, es correcto esto?...


Con respecto a calcular el angulo he visto en el pseudocodigo que para calcular el angulo envias tres parametros, Picos(0), Picos(k), Picos(j), por que no se envian solo dos parametros? punto central y punto del que se quiere saber el angulo?

" Si dos o más puntos tuvieran casualmente el mismo ángulo, se toma por bueno el que quede mas lejos "
Supongo que sera mas lejos del punto que se toma como central para calcular los angulos en este caso el punto B.

Estas serian las primeras dudas, ya que por esto voy a arrancar:

Sobre el pseodocodigo:
si, la figura es toda negra y el fondo es blanco.
si aplico este pseudocodigo pasara lo de la imagen de arriba, cada vez que detecte pixel negro se agregara al array, pero esto no garantiza que el pixel que se agrega sea el punto saliente sino que sera un posible punto saliente y entre esas posibilidades esta el que se busca (el mas saliente de ese pico) que se detectara con su angulo mayor al de los demas (para ese pico).



Sobre el algoritmo de Bresenham, lo busque y lo estuve viendo, algunas cosas las entiendo otras no... igual para mi suerte puede implementarlo y usarlo para hacer lineas rectas, eso queda pendiente saber como funciona al 100% ese algoritmo, una de las dudas era:
p = 2*dy - dx; Eso se puede leer como: 2 veces la distancia en el eje 'y' menos 1 vez la distancia en el eje 'x' pero no se que es eso visto del punto de vista de la matematica, que representa, que nombre tiene, que significa... etc.

He escrito algo de codigo, el codigo resuelve el primer cuadrante de cada imagen, los cuadrantes se cuentan en sentido contrario a las agujas del reloj, lo hice asi por que asi habia comenzado a hacerlo con la idea anterior (la del scanner con lineas diagonales) y para no perder tiempo modificando algo que ya estaba hecho lo hice de esta manera

El codigo tiene algunos comentarios, se hace partiendo desde la deteccion de poligono ya que lo anterior es para convertir la img en escala de grises y sacar los bordes, pintar la img etc. Tambien se incluye la imagen (que trae 5 imagenes dentro 5 en 1) esta img se llama "a.png". Al ejecutar el programa guarda en el disco "D:/" varias imagenes, que son los pasos del programa, las que tienen mas importancia son las imagenes llamadas "PPS0.png", "PPS1.png"... en esas imagenes se ven los resultados del scanner horizontal donde cada posible punto saliente es marcado en verde, los puntos rojos son los puntos mas salientes de cada lado. Luego las imagenes que se llaman "TrazarLineaX.png"... son las imagenes que muestran los puntos mas salientes y los posibles puntos salientes pero ademas de eso tambien muestra los puntos salientes que resuelven ese cuadrante (puntos de color azul), en la imagen 4 hay un error que es por la forma en que se calculan los angulos entre dos puntos, toma una recta en el eje de absisas positivo como perteneciente al cuadrante 4 entonces eso hace que tenga angulo de 360 cuando tiene 0.

subido a google drive.
link del codigo = https://drive.google.com/open?id=0B1i-JNEuRD1zU3JPOWlVbzhOLUU

PD: en entos dias subire una imagen que refleje una duda que tengo sobre esta forma de detectar los puntos salientes.

Saludos.

hola NEBIRE que tal, comento esto para preguntarte sobre la parte de las lineas azules, si mal no entendi la idea seria esta:
1) calcular el centro: diviendo la distancia horizontal /2 idem para la distancia vertical

2)Luego detectar la cantidad de picos minimos, esto se haria trazando una linea y detectar cuantas veces la linea corta con la imagen, siendo impar -> entrada a img, par -> salida a la img cada vez que entre o salga de la figura sumara un contador++, luego divido /2 y obtengo los posibles picos minimos a detectar.

3) y aqui viene mi principal duda, si no entendi mal lo que debo hacer es definir el cuadrante, cada cuadrante estara limitado por los 4 puntos que me daran 4 cuadrantes, elijo el primer cuadrante en sentido a las agujas del reloj, si la linea toca la figura en ese cuadrante entonces yo debo tener la cantidad minima de picos y debo buscarlos en este cuadrante para luego pasar al siguiente.
Para buscar esos picos de hacer:
Con un "scanner"  horizontal, que valla aumentando filas de a 1 y en cada fila evaluara los pixeles uno por uno de izquierda a derecha, las filas hiran de arriba hacia abajo y haria un "scanner" vertical que hira sumando columnas de a 1 y en cada columna evaluara cada pixel de abajo hacia arriba, las columnas hiran de derecha a izquierda (teniendo en cuenta la img 1)
Cada pico tendra dos puntos salientes a detectar, el superior (que lo detectara el scanner horizontal, y el punto saliente que esta mas a la derecha, que lo detectara el scanner vertical).
Y la duda es: ¿como los detecto? lei lo que escribiste pero no pude encontrar por mas de que quise asimilarlo la forma de detectar los 2 puntos salientes de cada pico (superior y el de la derecha). Esta parte me genera dudas

"cada vez que una línea encuentre lo más a la derecha un contorno, en la siguientes líneas (el bucle interno anidado) empezamos en esa posición,"

entiendo la idea pero no entiendo el funcionamiento de los bucles, el externo mueve en lineas y el interno mueve en pixeles de cada linea y cuando se detecta un borde saliente superior (no se como lo detectaria) el bucle interno de pixeles va a arrancar en la siguiente linea en la posicion que detecto en la anterior no arrancara desde el comienzo.
idem para scanner vertical.

4) Una vez detectado los puntos de cada pico se trazan linea desde el punto final (o el punto de origen) hacia cada punto detectado y la linea que tenga mayor angulo sera el punto mas saliente.

Espero no molestar mucho... Saludos.

PD: alguien no tendra el link de un post que hable sobre como hacer lineas en java? no me refiero al elemento graphics sino a calcular los puntos de la linea que pasa por dos puntos, lo logre hacer con trigonometria, y con funciones lineales, pero al comparar mis lineas con las del elemento graphics no son iguales tienes unas pequeñas diferencias, estare subiendo el codigo de las lineas mas tarde.

Hola todos, hago una actualizacion de esto, he hecho un "parentesis" por que me puse a ver como podria detectar un punto saliente que este entre 2 puntos salientes, siguiendo con la idea que me dio NEBIRE he trazado lineas entre los 2 puntos y ¿como iba a hacer para que el programa detecte el punto saliente del medio?.
Se me ocurrieron 2 formas. La primer manera:
En cualquiera de la dos ideas se tiene un recorrido/ruta que no es mas que los pixeles de una linea, ese recorrido sera lo que indique la direccion del "scanner" que tampoco es mas que una linea donde entre sus puntos en algun momento estara el pixel saliente del medio, en la idea uno el recorrido se marca con una linea amarilla y el escaner con una linea roja, los puntos salientes con azul y con verde el centroide que es el centro de la figura por ultimo de color negro dibujo la linea que une un punto con el otro:




Donde la linea amarilla es el recorrido del scanner, que es la linea roja y este scanner se va moviendo hacia uno de los puntos de la linea.
Para hacer esto superficialmente lo que se hace es:

Calcular angulo de la linea que va desde el punto de salida hasta el punto de llegada, en este caso (foto) el punto de salida es el de abajo, entonces metemos ese punto en un eje cartesiano y calculamos el angulo con el otro punto, esto se hace con trigonometria
Para eso hay que detectar el cuadrante del vector y sumar los angulos del cuadrante anterior: En la imagen al angulo de color celeste se le suman 0 grados, al de marron se le suman 90 grados,  y asi con los demas angulos...


Una vez con ese angulo se hace la linea que une esos dos puntos tambien con trigonometria. Despues de esto tenemos una line hecho desde un punto hasta otro punto. (los dos mas salientes),

Lo siguiente es calcular el angulo entre el punto centroide y el punto de salida de la linea, esto se hace de la misma forma:



Con este angulo se puede trazar la lines de recorrido:  (linea amarilla) de ahi sale la linea amarilla de la imagen de arriba.



Una vez hecho eso solamente queda comprobar, para comprobar hay que meter en un array cada punto de la linea amarilla (solo la linea amarilla), e ir recorriendo cada punto uno a uno desde el ultimo hasta el primero (se recorre al revez por que se quiere detectar desde afuera hacia adentro) y por cada punto de esos hara una nueva linea, la linea scanner, para hacer la linea usara el angulo de la linea negra:





Forma 2:

Es lo mismo que antes pero cambia en que en ves de calcular la linea de recorrido con un angulo igual al angulo entre centroide y punto de salida lo que hace es calcularla a noventa grados del angulo de la linea, se obtendria esto:



para obtener la linea que es perpendicular se puede sumar o restar 90 grados al angulo de la linea el problema es que a veces habra que sumar y otras veces habra que restar
entonces para saber eso tengo que tener en cuenta que para trazar una una ruta de trayecto/recorrido para el scanner tengo que alejarme del punto centroide y para poder alejarme se tiene primero que: calcular angulo entre punto saliente y centroide, luego sumar 90 grados al angulo (que ya existe calculado antes, arriba) de la linea que se habia llamado "alpha" y obtengo una de las 2 rectas de noventa grados para tener la otra tengo que restar 90 grados al mismo angulo que antes le habia sumado, ¿cual recta elijo?. Para responder esa pregunta hace falta saber la diferencia entre los 3 angulos que se tienen que son marron,violeta,verde:



negro = es el angulo de la linea
marron = es el angulo de la linea + 90 grados.
violeta = es el angulo de la linea -90 grados.
verde = es el angulo entre el punto saliente y el centroide

y ahora hacemos las diferencias:

marron - verde = diferencia entre el angulos+90 y el angulo con centroide
violeta - verde = diferencia entre el angulo-90 y el angulo con centroide

de los dos angulos que me importan (angulo+90 y angulo-90) voy a tomar el que me de mayor diferencia con el angulo centroide por que eso quiere decir que en ese angulo me voy alejar del punto centroide la diferencia seria esta:



la diferencia es bastante en este caso, lo que sigue es igual, se traza la linea amarilla a 90 grados, se recorre esa linea desde fuera hacia dentro y en cada pixel de la linea amarilla trazara nuevas lineas (linea roja, scanner) con el angulo de la linea negra.

Aqui dejo un codigo que ilustra esto:
El codigo es una animacion que muestra los dos tipos de deteccion, si se fijan en la clase Principal hay varias opciones de configuracion, si ponen el valor de la propiedad "tipoDeDeteccion" = 1 veran la forma 1 que explique antes y si ponen "tipoDeDeteccion" = 2 veran la segunda forma, ademas hay una imagen de salida que se guarda en "D:/salidaDiagonales.png" por si quieren ver, la linea de recorrido del scanner se traza en verde, no en amarillo, por ultimo pueden cambiar el punto por defecto por uno que ustedes quieran, y esto me lleva a mencionar algunos errores que pueden pasar...

si ponen tipo de deteccion = 1 y ponen 2 puntos que esten a 45 grados ej: (10,10);(20,20) veran como la deteccion no hace su trabajo como debe ser.
Si ponen tipo de deteccion = 2 hay angulos entre puntos que hara que el programa no sepa que elegir, por ejemplo el punto (10,10);(10,10) al poner ese punto en el momento de elegir el recorrido del scanner hara la diferencia y ambas diferencias son iguales entonces el programa no sabe que elegir...
Espero no haberme olvidado de algo, ya estare viendo si puedo icluir esto en la deteccion de las imagenes de arriba. Saludos.

Subido a googleDrive
Link: https://drive.google.com/open?id=0B1i-JNEuRD1zOEdoX0Z0NHFpNlU

como elimino este mensaje? lo publique solo sin querer.

Hola NEBIRE gracias por tus respuesta y tiempo, estuve viendo tu pseudocodigo y me parece bastante buena idea, si no me equivoco lo que me dices que haga es que formar poligonos donde cada lado del poligono estara definido por puntos salientes de la figura que se encuentren al lado, luego comparar los  poligonos y ver sus similitudes por medio de sus angulos, la verdad que tiene mucho sentido. Asi que me puse a ver si podia al menor comenzar con eso. Asi que al codigo que subi antes le agregue la clase "comparador" donde escribi algunos metodos entre ellos estan: un metodo que encuentra los primeros cuatro puntos saliente (superior, inferior, derecho, izquierdo), luego con esos puntos salientes se calcula en punto central de cada imagen, ademas tambien pinta las imagenes por dentro, las imagenes devueltas por java son estas:

(no se alcanzan a ver, pero si hacen zoom con el navegador podran notar 5 puntos, uno central y los demas son los primeros 4 puntos salientes)




El siguiente paso si no me equivoco es hacer una linea entre 2 puntos salientes que esten al lado y verificar si toca a la figura, en ese caso comprobara un nuevo punto saliente entre medio de esos 2 puntos y hara una linea nueva. Apenas puedo intentare eso y estare actualizando el post. Aqui dejo el codigo. Suerte.

String link = "https://drive.google.com/open?id=0B1i-JNEuRD1zWVFvVG4xcFpCN2s";

Hola buenas noches a todos. Un amigo me desafio a ver si podia resolver algo, el desafio consistia en hacer que la computadora reconozca dos imagenes de entre 5, esas dos imagenes son la misma imagen pero con algunas modificaciones. Mejor les dejo algunas imagenes para que se entienda mejor la imagen del desafio es esta:



Lo primero que hice fue pintar el fondo de negro y filtrar la imagen a escala de grises y obtuve esto:




Luego lo que hice fue separar las subimagenes y obtener su borde y obtuve estas:







Ahora no se como continuar, queria saber como hago para detectar similitudes entre las imagenes, no puedo hacerlo por medio del color de los pixeles ya que las imagenes varian sus colores, aqui dio casualidad que justo el amarillo esta en ambas imagenes iguales pero la forma es lo que vale ya que a veces tocan colores muy distintos.

Queria saber si alguien tiene conocimiento sobre detectar patrones en las imagenes que me permitan saber que figura tengo alli, o algun libro o pdf que hable del tema.

Aqui les dejo el codigo con que he estado intentando, esta incluida la imagen del desafio, esta hecho en java y se me hizo un poquito espaguetti jaja pero esta todo comentado. Suerte.

Link: https://drive.google.com/open?id=0B1i-JNEuRD1zV3FQTmJ6X2pBN3M

[· Los códigos deben ir en etiquetas GeSHi >aquí las reglas del foro -Engel Lex]

Que tal amigo gracias por responder, hice esto:

Código (html4strict) [Seleccionar] Expandir

var img = document.createElement('img'); //creo nueva imagen
img.src = "url('/imagen.php')" //esto es la url del fondo del contenedor q se lo asigno a la nueva img

var canvas = document.createElement('canvas'); //elemento canvas

canvas.width = 700; //ancho
canvas.height = 800; //alto
ctx = canvas.getContext('2d') //contexto
document.body.getElementsByTagName('div')[1].appendChild(canvas) // agrego canvas al dom

ctx.drawImage(img,0,0) // dibuja la imagen creada anteriormente

Este codigo funciono, en la pagina se veia un canvas con una imagen, el problema es que esta nueva imagen es distinta a la que yo quiero, es como si la funcion URL se ejecutara nuevamente y enviara otra imagen distinta. Sera posible detectar el color de los pixeles en el DOM para luego pintarlos en el canvas y finalmente del canvas llegar a .jpg.?


· Los códigos deben ir en etiquetas GeSHi
>aquí las reglas del foro
-Engel Lex