SlotGen : generador de circuits slot

Anuncio
Departament d’Enginyeria Informàtica i Matemàtiques
SlotGen : generador de circuits slot
TITULACIÓ: Enginyeria Tècnica en Informàtica de Sistemes
AUTOR: Diego Franco Pérez
DIRECTOR: Pere Millán Marco
DATA: 4 de Setembre 2014
SlotGen
Generador de circuits slot
Índex
1- Objectius del projecte ..................................................................................................... 4
2- Especificacions del projecte ........................................................................................... 5
3- Disseny ........................................................................................................................... 8
4.1-
Representació interna de les pistes ......................................................................... 8
4.2-
Validació d’un circuit ........................................................................................... 11
4.3-
Generació dels circuits .......................................................................................... 13
4.3.1- Generació aleatòria ............................................................................................ 13
4.3.2- Generació segons traçat desitjat ......................................................................... 14
4.3.3- Generació amb backtracking.............................................................................. 16
4.4-
Dibuix de les pistes i de la interfície gràfica ......................................................... 17
4- Desenvolupament ......................................................................................................... 18
5.1- UML ......................................................................................................................... 21
5.1.1 Model de les pistes .............................................................................................. 21
5.1.2 Model dels mètodes de generació ....................................................................... 23
5.1.3 Model de la finestra principal.............................................................................. 24
5.1.4 Model dels esdeveniments de la finestra principal.............................................. 25
5.1.5 Model de la finestra de detall .............................................................................. 27
5.1.6 Model dels esdeveniments de la finestra de detall .............................................. 28
5- Avaluacions (relació de les proves realitzades per avaluar cada part) ......................... 29
6- Conclusions .................................................................................................................. 37
7- Recursos utilitzats ........................................................................................................ 38
7.1-
Bibliografia ........................................................................................................... 38
7.2-
Pàgines web .......................................................................................................... 38
7.3-
Programari ............................................................................................................ 38
8- Annexes ........................................................................................................................ 39
8.1-
Instal·lació ............................................................................................................ 39
8.2-
Requeriments ........................................................................................................ 39
8.3-
Manual d’ús .......................................................................................................... 39
8.3.1-
Pantalla principal ........................................................................................... 39
8.3.2-
Pantalla de detall ............................................................................................ 40
8.4-
Índex de figures .................................................................................................... 41
9- Resum (Resumen/Abstract).......................................................................................... 42
9.1-
Català .................................................................................................................... 42
2
SlotGen
Generador de circuits slot
9.2-
Español.................................................................................................................. 43
9.3-
English .................................................................................................................. 44
3
SlotGen
Generador de circuits slot
1- Objectius del projecte
El desenvolupament d’aquest programa sorgeix de la voluntat de crear un circuit de slot.
Un dia vaig buscar per Internet si havia algun tipus de programa que generés circuits
d’alguna forma, per tal de no haver fer moltes proves i agafar idees de traçats. El resultat
de la recerca va ser que al mercat hi ha diversos programes de disseny de circuits, que són
molt útils per fer-ho de forma manual, sense haver de fer proves muntant el circuit
físicament. Però no vaig trobar-ne cap que disposés de la funció que buscava i a alguns
fòrums vaig poder comprovar que jo no era l’única persona que ha buscat una utilitat
similar.
Vaig pensar que seria molt útil poder obtenir diversos circuits possibles a partir de les
pistes de què disposa l’usuari i també d’una superfície específica. Tenint en compte
aquestes circumstàncies, aquesta solució permetria crear un gran ventall de circuits nous
defugint els típics circuits que apareixen a llibrets d’instruccions comercials.
L’ampli ventall de resultats que s’obtindrien és un valor afegit, ja que difícilment
arribaríem a muntar tants circuits diferents amb un dissenyador de circuits manual, dels
que funcionen creant la traçada pista a pista, a partir d’una sola idea prèvia o de la
imaginació de l’usuari.
El que s’ha intentat és ajustar les característiques del programa a les necessitats reals en
què es troba un usuari potencial, aconseguint que els resultats siguin satisfactoris i,
sobretot, realitzables. És sorprenent la quantitat de circuits nous que es poden crear amb les
pistes que sempre has utilitzat.
També m’interessa molt aquest tipus de projecte, ja que la construcció del circuit requereix
una avaluació de com representar les pistes, calcular com s’enllacen entre elles i
comprovar si realment el conjunt representa un traçat vàlid per a l’usuari.
4
SlotGen
Generador de circuits slot
2- Especificacions del projecte
Per realitzar aquest projecte necessitem almenys disposar d’un conjunt de pistes de slot. En
aquest cas, l’aplicació s’haurà d’orientar a la generació de pistes amb les mides de la marca
Ninco, però el codi haurà de possibilitar la implementació d’altres marques i mides.
Les característiques de les pistes de la marca Ninco són les següents:
Figura 1: Tipus de rectes
Figura 2: Tipus de corbes
El programa es desenvolupa en Java 1.7 i està pensat per executar-se en un ordinador. Es
distribuirà empaquetat en un fitxer .jar executable i és multiSO, però la part visual està
orientada a Windows 7.
5
SlotGen
Generador de circuits slot
Una vegada executat el programa, es mostra la pantalla principal amb cinc parts ben
diferenciades:
Figura 3: Pantalla principal de l'aplicació
A la part dreta es troba, en primer lloc, la secció Pistes i Superfície, on hi ha una relació
dels tipus de pistes admesos (descripció de la pista i imatge). Mitjançant caixes de text,
l’usuari introdueix les pistes amb què vol generar el circuit i, opcionalment, la superfície a
la qual s’ha d’ajustar. Com a requisit obligatori per poder generar un circuit es demana
haver introduït, com a mínim, una recta de 40 cm. Aquesta pista correspon a la que conté
les connexions dels comandaments.
A continuació es troba la secció de Resultats, amb les diferents opcions per generar un
circuit segons les preferències:
-
-
Aleatori: és un mode de generar circuits relativament aleatori, mitjançant un
sistema de probabilitats segons la quantitat de pistes que hi ha de cada tipus. A més
quantitat, més probabilitat de què surtin seguides.
Tots els circuits possibles: mitjançant el mètode de tornada enrere (backtracking).
Aquesta opció troba tots els circuits generables amb les pistes introduïdes.
Traçada: Mitjançant un control lliscador (slider) assigna més o menys probabilitat
a les pistes rectes i corbes, de forma que els circuits resultants siguin més sinuosos
o més rectilinis.
A sota hi ha la part on es pot introduir el temps màxim de cerca: es pot introduir el límit de
temps que l’usuari vol esperar generant circuits, on com a mínim es pot introduir 1 segon.
6
SlotGen
Generador de circuits slot
A la part central de la pantalla hi trobem el panell de resultats amb el logo del programa
visible mentre no n’hi hagi cap, que s’anirà omplint a mesura que el programa trobi circuits
vàlids. Aquest panell és pot desplaçar verticalment per tal de poder veure tots els resultats
obtinguts.
Finalment, a la part inferior de la finestra hi ha una barra de progrés, que indica a l’usuari
quant queda per finalitzar el procés de generació i el total de circuits trobats. A la part
inferior dreta es troben els botons de Generar i Aturar, que permeten començar la cerca de
circuits i aturar-la en qualsevol moment, respectivament.
En seleccionar un dels circuits mostrats a la pantalla principal, s’obre la finestra de detall
del circuit:
Aquesta nova finestra té una disposició dels elements similar a la principal. A la part dreta
tenim informació del circuit:
-
-
Dimensions del circuit: informació sobre la superfície de què disposa l’usuari i la
que realment ocuparia el circuit muntat.
Longitud dels recorreguts: és una dada molt útil per saber quina distància
recorrerien els dos cotxes i poder valorar si s’adequa a les seves preferències. Uns
recorreguts equilibrats seria ideal, però segons en quins casos la diferència de
longitud dels carrils es pot compensar gràcies a què els cotxes assoliran diferents
màxims de velocitat.
Resum de pistes: es mostra en una taula la quantitat de pistes usades per formar el
circuit i les pistes de què es disposava.
A la part central hi ha el panell amb el circuit seleccionat, el qual es pot fer zoom
mitjançant la rodeta del ratolí. D’aquesta manera es pot observar amb més detall i a la mida
que l’usuari necessiti el traçat.
Per acabar, a la part inferior de la finestra hi ha la seqüència de pistes en ordre de
muntatge, per facilitar l’usuari aquest treball.
Figura 4:Finestra de detall del circuit
7
SlotGen
Generador de circuits slot
3- Disseny
El disseny de l’aplicació consta de dues capes separades: la part de generació del circuit i
la part gràfica.
La generació del circuit engloba la representació interna de les pistes que conformen un
circuit, les comprovacions per validar si el circuit és correcte i l’algorisme de generació
dels circuits.
A l’apartat gràfic es diferencien dues parts: la implementació de la interfície gràfica i el
dibuixat de les pistes que formen el circuit.
4.1-
Representació interna de les pistes
Per tal de manipular i representar en un sistema de coordenades XY qualsevol tipus de
pista (rectes i corbes de qualsevol angle i radi) s’ha trobat que un segment seria la manera
més senzilla de fer-ho. D’aquesta manera, una forma complicada com és una corba o una
recta en 2 dimensions, queda reduïda a un segment amb un punts inicial i final coneguts i
determinats per les característiques de la pista física. Finalment, un circuit serà format per
un conjunt de segments i serà fàcil identificar els punts d’inici i final per tal de decidir si és
un circuit tancat o si compleix els criteris de l’usuari.
Figura 5: Esquema de la Recta 40 cm
Com es veu a la Figura 5, per representar la pista de 40 cm de llargada i 18 d’amplada
s’utilitza un segment delimitat pels punts Pini i Pfin. La inclinació de la pista vindrà
determinada per la pista anterior.
8
SlotGen
Generador de circuits slot
Figura 6: Esquema de la corba estàndard
A la figura 6 hi ha representada la corba més habitual en els kits comercials. Es tracta de la
corba estàndard, que té un gir de 45º i un diàmetre extern de 84,3 cm. Al gràfic, la pista
real està definida amb el punt C com a centre de la circumferència que descriu la corba,
l’angle α, i els arcs compresos entre els punts EH com a part interna, i l’arc FM com a part
exterior de la pista.
Per simplificar aquest tipus de pista s’ha definit el segment BA. Podem observar que la
inclinació del segment respecte l’eix X de coordenades no correspon amb l’angle del gir de
la corba, concretament és la meitat, en aquest cas, 22,5º. També s’ha de tenir en compte
que l’encaix de la següent pista ha de coincidir amb la perpendicular del segment HM. Per
tant, l’angle final de la pista es un altre paràmetre que s’ha de tenir en compte per tal de fer
la composició entre les pistes. En aquest cas, l’angle final de la pista respecte l’eix X és de
45º, el mateix que el gir de la pista física.
9
SlotGen
Generador de circuits slot
Per demostrar la importància d’aquest angle final, observem la següent il·lustració:
Figura 7: Unió de dues pistes corbes.
Podem veure una pista corba estàndard inicial definida pel segment AI, i dues possibles
corbes següents: una girant en el sentit horari definit pel segment IJ i l’altra girant en sentit
antihorari, segment IJ’. La importància de tenir sempre controlat aquest angle final radica
en què aquest serà l’angle inicial de la següent pista.
A l’exemple, la pista definida per AI té un angle inicial de 0º, fa un gir en sentit horari de
45º, la qual cosa implica que la següent pista té un angle inicial de -45º (fletxa N). Per tant,
l’angle final de la pista IJ seria de -90º (fletxa L). De la mateixa manera, si la segona pista
girés en sentit horari, com que l’angle inicial era de -45º i la pista gira en sentit horari li
suma 45º, per tant l’angle final de la pista IJ’ seria de 0º (paral·lel a l’eix X) tal i com
indica la fletxa M.
Aquesta dada també es molt útil per tal de traspassar aquesta representació senzilla de les
pistes i dels circuits a l’entorn 2D en el qual s’han de dibuixar les pistes.
10
SlotGen
Generador de circuits slot
4.2-
Validació d’un circuit
Per tal donar per bo un circuit, s’han de complir una sèrie de condicions:
El conjunt de pistes ha de formar un circuit tancat. Aquesta és la condició bàsica per poder
acceptar un circuit com a vàlid, i que l’angle final de la última pista sigui el mateix que
l’angle inicial de la primera pista. D’aquesta manera s’assegura que hi ha continuïtat entre
les pistes. S’ha de tenir en compte que pot haver un petit marge d’error entre el punt inicial
i el final, ja que les pistes físiques poden tenir una mica de joc i no són tan precises com els
càlculs que es pot realitzar mitjançant software (que també té un petit error de càlcul, però
en aquest cas es menyspreable).
No es pot repetir amb un altre trobat anteriorment: s’ha d’evitar mostrar a l’usuari circuits
repetits. Aquesta condició provoca una complicació en la comparació de circuits ja que
s’està comparant una llista de dades de forma circular. Això provoca un gran nombre de
comparacions ja que per comparar 2 circuits s’haurien de fer n*n iteracions.
Figura 8: Circuits equivalents
A la figura 8 hi ha representat un exemple de circuits equivalents. La pista ombrejada de
blau representa la primera pista que hi hauria emmagatzemada, per detectar que els dos
circuits són idèntics s’hauria de trobar una manera de fer coincidir el començament
d’ambdós circuits, per tal d’evitar un excés d’iteracions.
Per minimitzar aquest problema s’ha pres la decisió que un circuit generat sempre ha de
començar per una recta de 40 cm i l’última pista no pot ser cap tipus de recta. Amb
aquestes limitacions s’evita generar alguns circuits idèntics i rotats, i també té una lògica
aplicada al circuit real, ja que els comandaments s’endollen a una pista d’aquest tipus.
Per tal de detectar i descartar circuits rotats, s’ha ideat un sistema que evita recórrer
totalment totes les pistes dels dos circuits a comparar. El concepte consisteix en situar
sempre com a principi de circuit la recta (o rectes) més llarga del circuit. Per poder detectar
quines són les pistes més llargues i la posició de cadascuna d’elles, s’ha pensat mantenir
aquestes dades en 2 vectors. Prenent l’exemple de la Figura 6, de cada circuit s’extreuen
les següents dades:
11
SlotGen
Generador de circuits slot
-
-
Circuit A:
o Posició de la primera recta (d’un conjunt)
o Longitud de la recta (o conjunt)
Circuit B:
o Posició de la primera recta (d’un conjunt)
o Longitud de la recta (o conjunt)
[ 0,
[ 1,
2,
2,
7,
1,
9]
2]
[ 0,
[ 2,
5,
1,
7,
2,
12]
1]
Amb aquestes dades es veu com amb només 2 recorreguts com a màxim del circuit ja es
detecta que són equivalents. El procés començaria per la pista número 2 del circuit A i la
pista número 0 del circuit B i, en aquest cas, a la primera validació ja detectaria que són
duplicats.
Amb aquest sistema, el millor cas possible seria que el circuit tingués un tram amb més
pistes rectes que la resta de trams, sense importar la longitud de les rectes. En aquesta
situació, amb una sola comparació de totes les pistes del circuit seria suficient per
comprovar si està repetit.
Contràriament, el pitjor cas possible seria que tots el trams de rectes tinguessin el mateix
nombre de rectes. La quantitat de comparacions necessàries seria igual al número de trams
de rectes que tingués el circuit.
Hi ha un tipus de comparació entre circuits que s’ha decidit no implementar. Aquest cas és
el circuit “reflectit”, és a dir, els circuits són els mateixos però com si es miressin amb un
mirall:
Figura 9: Circuits reflectits
La validació d’aquest circuit implicaria, com es veu a simple vista, recórrer un circuit en
sentit horari i l’altre en sentit antihorari.
Aquesta decisió s’ha pres pel cost computacional que afegiria, i s’ha comprovat
empíricament que la quantitat de circuits d’aquest tipus que apareixen com a resultat no és
elevat. Per tant, s’intenta que hi hagi un compromís entre la qualitat dels resultats i el que
costa validar-los.
12
SlotGen
Generador de circuits slot
4.3-
Generació dels circuits
S’ha pensat tres mètodes de generació de circuits que pot escollir l’usuari: aleatori, segons
traçat i tots els circuits possibles.
4.3.1- Generació aleatòria
El mètode de generació aleatòria es basa en el mateix procés que faria una persona quan es
disposa a muntar un circuit: separar les pistes segons el tipus i apilar-les per separat. Una
vegada apilades, a cada pila se li assigna una probabilitat de ser seleccionada per extreure
una de les pistes i afegir-la al possible circuit. En el següent pas, la probabilitat es recalcula
segons la quantitat de pistes disponibles.
Probabilitat de la pila = núm pistes pila / núm total de pistes
Aquesta probabilitat que es calcula contínuament en funció de les pistes que queden
apilades, respon a la lògica d’intentar usar el màxim de pistes possibles. Això fa que el
mètode no sigui completament aleatori, és dependent del número de pistes i del tipus.
Pila 1
nPistes = 5
Prob = 0,5
Pila 2
nPistes = 3
Prob = 0,3
Pila 3
nPistes = 2
Prob = 0,2
1 <rand< 0,5
0,5 <rand< 0,2
0,2 <rand< 0
Número aleatori
entre 0 i 1 (rand)
Com mostra l’esquema, es genera un número aleatori entre 0 i 1, que el programa
interpreta com la probabilitat. Segons la probabilitat assignada a cada pila, es crea un rang
de números. En el cas de l’esquema, si el generador de números aleatoris retorna un valor
dintre del rang de la pila 1, es desapilarà una pista d’aquesta pila, s’afegirà a la llista de
pistes del circuit, de forma que el següent estat de les piles seria:
13
SlotGen
Generador de circuits slot
Pila 1
nPistes = 4
Prob = 0,44
Pila 2
nPistes = 3
Prob = 0,33
Pila 3
nPistes = 2
Prob = 0,22
1 <rand< 0,56
0,56<rand<0,23
0,23 <rand< 0
Número aleatori
entre 0 i 1 (rand)
Poc a poc les probabilitats es van igualant entre totes les piles (però sempre depèn del
número aleatori generat).
En quant a les pistes seleccionades, en el cas que sigui seleccionada una recta no hi ha cap
problema, però si la pista seleccionada és una corba, s’ha de decidir en quin sentit girarà.
Per decidir això, aprofitant que el mètode ha de ser el més aleatori possible, s’utilitza el
mateix número aleatori generat per triar la pila, per tal d’escollir si gira en un sentit o en
altre, doncs la probabilitat serà del 50%.
4.3.2- Generació segons traçat desitjat
Per tal que l’usuari tingui un mínim de control sobre el tipus de circuit que s’ha de generar,
se li proporciona una opció per triar la configuració del circuit, ja sigui un circuit amb
llargues rectes o un circuit amb moltes corbes i molt sinuós. Aquest control no impedeix
que la generació dels circuits continuï tenint un grau d’aleatorietat.
Aprofitant el mateix sistema que s’ha desenvolupat per a la generació aleatòria, s’ha
decidit apilar les pistes de la mateixa manera i assignar probabilitats a les piles. Aquest
cop, la probabilitat d’escollir cada pila, no estarà determinada pel nombre de pistes sinó per
un valor que introduirà l’usuari mitjançant un slider.
De cara a l’usuari, no ha de saber quina probabilitat està assignant a les piles, només ha de
comprovar que els circuits que es generen són diferents segons la posició del slider.
14
SlotGen
Generador de circuits slot
A la següent il·lustració hi ha un exemple en què l’usuari hauria seleccionat un 80% de
probabilitat de corbes, que es reparteix equitativament entre les piles dels diferents tipus
que hi ha. D’igual forma, el 20% restant corresponent a les piles de rectes, es reparteix
equitativament entre elles de forma que la probabilitat de treure una pista recta de
qualsevol tipus es la mateixa:
Probabilitat Piles Recta = prob. usuari / núm piles Recta usades
Probabilitat Piles Corba = (1-prob. usuari) / núm piles Corba usades
Pila 1
Recta 10
Pila 2
Recta 20
Pila 3
Recta 40
Pila 4
C. Interior
Pila 5
Pila 6
C. Exterior
C. Estàndard
Recta
20%
Pila 7
C. SuperExt
Corba
15
.
80%
SlotGen
Generador de circuits slot
4.3.3- Generació amb backtracking
El patró de backtracking és un mètode de resolució de problemes que té una solució
completa i on l’ordre dels elements no importa. La idea bàsica d’aquest patró resideix en
triar un element de tots els disponibles i afegir-lo a la estructura del que seria la hipotètica
solució i comprovar si realment és solució al problema. Si no ho és, es desfà el moviment
realitzat i es prova amb un altre element. Aquest procés de desfer/tornar enrere es fa
mitjançant la implementació d’una funció recursiva, que en finalitzar torna a l’estat
anterior des d’on ha estat cridada. El major inconvenient d’aquest tipus de patró és el seu
cost, gairebé sempre és exponencial.
Si es desenvolupa el conjunt de decisions que pren l’algoritme s’acaba formant un arbre de
decisions:
Figura 10: Arbre de decisió backtracking
Per al cas de generació de circuits, les pistes introduïdes per l’usuari s’afegeixen a una
llista i s’utilitza una llista auxiliar amb la que es comprovarà si és una solució vàlida o no.
L’algoritme de backtraking té diferents possibilitats a l’hora de trobar els resultats. Hi ha
l’opció d’aturar el procés en quant trobi el primer resultat vàlid, trobar el millor resultat o
trobar tots els resultats possibles. En el cas de la cerca de circuits, s’ha decidit que el millor
seria buscar tots els circuits possibles, malgrat que aquesta tasca por tenir una durada molt
llarga.
Encara que el mètode de backtracking pot arribar a no ser útil de cara a l’usuari pel temps
que pot arribar a trigar, s’inclou en la versió del programa per ampliar informació, però no
és realment útil.
16
SlotGen
Generador de circuits slot
4.4-
Dibuix de les pistes i de la interfície gràfica
La representació gràfica de les pistes ha de ser dibuixada mitjançant l’API de Java2D.
D’aquesta forma no s’utilitzen imatges que es poden pixelar quan s’escalen, i serà
adaptable per a tipus de pistes diferents, d’altres marques o nous models. També servirà
per aprendre a usar el conjunt de funcions de Java2D i les possibilitats que permet.
La interfície gràfica s’haurà de dissenyar en Swing ja que disposa dels components
necessaris pels elements que necessitarà l’aplicació, i en cas necessari crear-ne de nous per
ajustar-se a les necessitats de l’aplicació.
17
SlotGen
Generador de circuits slot
4- Desenvolupament
El primer pas que es va haver de donar per començar a fer el projecte va ser estudiar com
s’havia de representar cadascuna de les pistes de manera que fos fàcil de programar i de
manipular. Una vegada trobat que el sistema dels segments i angles era el més adient, es va
intentar representar algun circuit senzill, amb la forma de ‘0’ i comprovar que els punts
realment corresponguessin amb la realitat.
Per realitzar aquesta fase va ser molt útil el programari Geogebra, és un programa molt
interessant per tal de representar diferents operacions i elements en un sistema de
coordenades. Aprofitant que aquest programa pot carregar fitxers de text tipus CSV, es va
implementar un mètode que exporta els punts dels segments en aquest fitxer, de forma que
era molt fàcil validar que els punts que s’estaven calculant eren els correctes.
Figura 11: Circuit circular Geogebra
A la figura 10 hi ha un exemple d’un circuit circular amb tots els punts relatius als
segments de cada pista i, en vermell, els punts que representen el centre de les corbes.
Una vegada la representació de les pistes era correcta, era el moment de començar a pensar
quin mètode de generació seria el més adient. El primer que va sorgir va ser permutar
elements d’un vector, ja que la implementació era prou ràpida per començar a fer proves i
intentar realitzar les validacions de circuit correcte.
18
SlotGen
Generador de circuits slot
Malgrat que el mètode de permutacions no era gaire ortodox i no servia per afegir corbes
en diferents sentits de gir, es va començar a fer la validació de circuits.
Quan la validació ja era funcional, es va realitzar la primera aproximació per generar
circuits aleatoris mitjançant probabilitat i, gràcies a aquest idea, la generació per traçat no
va ser gaire complicada. El que sí que he tingut problemes ha estat amb la generació
mitjançant backtracking ja que és difícil validar el seu correcte funcionament degut al
temps que triga a executar-se. A partir d’un número relativament baix de pistes (12) el
temps que triga en finalitzar és molt alt.
Una vegada la generació del circuit i la validació eren funcionals, es va començar a
implementar la part gràfica de l’aplicació. Primer es va fer el dibuix de les pistes. La recta
és més senzilla, ja que només és un rectangle mentre, que la corba ha donat més treball.
El mètode realitzat per dibuixar les pistes es mitjançant el que s’anomena una “figura
composta”, és a dir, a partir de formes senzilles realitzar una forma més complexa. El que
es realitza a aquestes classes són operacions de suma i resta amb les formes. Per exemple, a
la pista recta se segueix el següent procés:
1- Es dibuixa un rectangle a partir de punts calculats prèviament.
2- Es calcula per on han de passar els carrils, que estan a 1/4 de distància de l’amplada
de la pista.
3- Es creen 2 rectangles corresponents a les àrees dels carrils.
4- Es resten les àrees dels carrils de l’àrea del rectangle, de forma que tenim una
figura única amb la forma que desitgem.
D’igual manera, la creació de la pista corba és bastant curiosa:
1- Es dibuixa un arc de tipus pastís, ja que crea una forma de falca triangular amb el
centre calculat prèviament i radi fins la vora exterior de la pista.
2- Es dibuixa un altre arc del mateix tipus, amb el mateix centre i de radi fins la vora
interior de la pista.
3- Es resta la segona figura a la primera. En aquest moment es disposa de la figura de
la corba sense els carrils.
4- Seguint el mateix procés, es creen 4 arcs més que delimitaran els 2 carrils.
5- Es resta l’àrea dels carrils a la figura que s’ha creat al pas 2 i la figura resultant és la
desitjada.
Figura 12: Operació amb figures
19
SlotGen
Generador de circuits slot
La interfície gràfica d’usuari ha estat l’última part en desenvolupar-se, on s’ha intentat
seguir el patró Model-Vista-Controlador, encara que no hi hagi cap accés a una base de
dades.
La distribució dels components ha quedat de la següent manera:
-
Model: la representació esquemàtica de les pistes i la classe que guarda un circuit
amb les seves característiques, s’ha englobat dins d’aquesta part.
Vista: tant les classes corresponents a les finestres, com les classes encarregades de
dibuixar les pistes, estan incloses en aquest paquet.
Controlador: com a controlador s’ha afegit tots els manegadors d’esdeveniments de
la interfície gràfica i la classe encarregada de “transportar” les dades introduïdes
per l’usuari als mètodes que ho requereixin.
20
SlotGen
Generador de circuits slot
5.1- UML
5.1.1 Model de les pistes
Figura 13: UML representació de les pistes
En aquest model podem veure que les classes PistaCurva i PistaRecta hereten de la classe
Pista, que és abstracta i no es pot instanciar (una pista només té sentit si sabem de quin
tipus és). Aquesta classe pare conté els atributs comuns entre les pistes corbes i rectes, com
pot ser l’amplada de la pista, la longitud (del segment que representa la pista), els angles
inicials i finals de la pista, etc.
A part dels atributs en si de les pistes, les classes disposen de mètodes per tal de calcular
els punts i els angles que les defineixen. El mètode calcularPista és l’encarregat, i suposa
que hi ha una llista de pistes establerta, des d’on pot extreure les dades de la pista
immediatament anterior (angle final i punt final de la pista anterior passen a ser el punt
inicial i l’angle inicial de la pista actual).
21
SlotGen
Generador de circuits slot
Figura 14: UML dibuix de les pistes
El model de dibuix de les pistes és molt semblant al model anterior. A les classes
DibujoCurva i DibujoRecta es fan les operacions descrites anteriorment de manipulació de
figures per tal de crear la figura (Shape) de la pista. Aquestes operacions agafen com a
dades les que tenen les classes de representació de les pistes (apartat 5.1.1) i que s’han
calculat prèviament.
Només es fan les operacions de les figures si realment el circuit és correcte i es dibuixarà a
la pantalla. Una vegada obtingudes aquestes figures, s’emmagatzemen a la classe superior,
per tal de tenir un accés més simple a les figures. D’aquesta manera, per dibuixar una pista,
només s’ha de dibuixar amb el mètode de Java2D draw les figures contingudes en aquesta
classe.
22
SlotGen
Generador de circuits slot
5.1.2 Model dels mètodes de generació
Figura 15: UML mètodes de generació
-
Classe ProbabilidadPila: Aquesta classe conté les piles de cada tipus de pista i la
probabilitat associada. A més, implementa el mètode Comparable, per poder
ordenar els objectes d’aquesta classe dintre d’una col·lecció de Java.
-
Classe GenerarAleatorio: Usant la classe de probabilitat, apila les pistes
introduïdes per l’usuari amb el mètode crearApilar(). Després es va seleccionant
cada pista amb el mètode SeleccionaPista, dins del qual es va calculant cada cop la
probabilitat de les piles, ja que el total de pistes ha anat disminuint.
-
Classe Bactraking: Amb la funció crearCircuitoConstrucción, s’afegeixen en un
vector de pistes, el número i tipus de pistes què ha introduït l’usuari. Aquest vector
serà el que serveix per saber quantes pistes hi ha disponibles en cada crida
recursiva, de forma que quan quedi buit, haurà de retornar al context anterior
desfent el pas creat. Aquesta recursivitat està implementada al mètode back().
-
Classe Comprobaciones: Aquesta classe conté les validacions per acceptar o
rebutjar un circuit. A les funcions esCircuito... es fan les validacions descrites
anteriorment, utilitzant la funció esPistaRecta per validar que l’última pista del
circuit no sigui una pista recta de qualsevol longitud.
23
SlotGen
Generador de circuits slot
5.1.3 Model de la finestra principal
Figura 16: UML finestra principal
En aquest model es detallen tots els elements que composen la finestra principal.
24
SlotGen
Generador de circuits slot
5.1.4 Model dels esdeveniments de la finestra principal
Figura 17: UML esdeveniments finestra principal
-
SliderTimeEvent, MinutosSegundos: fa que el slider de temps i les caixes de text de
minuts i segons interactuïn, de forma que si es desplaça el slider s’informa les
caixes de text i viceversa.
-
PegaDecimales, SoloDecimales: evita introduir o “enganxar” números que no
tinguin el format decimal.
-
PegaEnteros, SoloEnteros: evita introduir o “enganxar” números que no siguin
enters.
-
ActionGenerar: esdeveniment que s’activa quan es clica el botó de Generar. És
l’encarregat de llançar la generació dels circuits segons les dades introduïdes per
l’usuari.
-
ActionDetener: atura en qualsevol moment el procés de generació de circuits.
-
ValidaR40: comprova que almenys hi hagi una recta de 40 cm informada per poder
començar la generació. Si no hi és, mostra una etiqueta de color vermell al costat,
per informar l’usuari.
-
RdbtTrazado: si se selecciona l’opció de generar per traçat, s’habilita el slider
associat. Mentre no està seleccionat, el slider roman deshabilitat.
25
SlotGen
Generador de circuits slot
Figura 18: UML esdeveniments panell resultats (miniatures)
Aquest manegador serveix per detectar si el cursor del ratolí està sobre algun dels circuits
que s’han generat (mouseEntered i mouseExited). Si el cursor està a sobre, canvia de color
el fons per indicar que és un element clicable.
Si es clica sobre un circuit (mouseReleased) s’obre la finestra de detall, mitjançant la crida
a runDetalle.
26
SlotGen
Generador de circuits slot
5.1.5 Model de la finestra de detall
Figura 19: UML finestra detall
27
SlotGen
Generador de circuits slot
5.1.6 Model dels esdeveniments de la finestra de detall
Figura 20: UML esdeveniments de finestra detall
-
Zoom: permet ampliar i reduir la mida del circuit que es mostra al panell de
resultats.
-
Arrastrar: detecta el punt i la distància recorreguda pel punter amb el botó esquerre
polsat. Amb aquestes dades es va redibuixant el circuit, per poder-lo traslladar de
lloc dintre del panell de resultats.
-
Cerrar: detecta que l’usuari tanca la finestra i evita sortir de l’aplicació des de la
finestra de detall, només tanca la pròpia finestra.
-
SwingAbrir: esdeveniment cridat quan se selecciona al menú l’opció de carregar un
circuit guardat a disc. També valida que el fitxer carregat sigui correcte.
-
SwingGuardar: esdeveniment que es crida quan l’usuari selecciona l’opció
corresponent al menú Opcions. Aquest esdeveniment també controla si es vol
sobreescriure un circuit existent a disc.
28
SlotGen
Generador de circuits slot
5- Avaluacions (relació de les proves realitzades per avaluar cada
part)
L’aplicació es distribueix en un JAR executable. Per tant és imprescindible disposar de la
màquina virtual de Java instal·lada en la versió 1.7. Per executar, només cal escriure a la
consola el comandament java –jar SlotGen.jar
Cerca amb el mètode aleatori i temps per defecte, 3 segons:
29
SlotGen
Generador de circuits slot
Amb les mateixes pistes afegim una limitació de superfície i comprovem com els resultats
tenen unes dimensions més reduïdes:
30
SlotGen
Generador de circuits slot
Al panell de detall podem realitzar un zoom sobre el circuit, girant la rodeta del ratolí:
31
SlotGen
Generador de circuits slot
També podrem desplaçar el circuit per tota l’àrea del panell on es dibuixa mitjançant el
mètode de clicar i arrastrar:
A la pantalla de detall es pot carregar o desar un fitxer de circuit. D’aquesta forma l’usuari
podrà tenir sempre disponibles els circuits què més li han agradat:
32
SlotGen
Generador de circuits slot
Si escollim l’opció de generació segons el traçat i seleccionem que faci un circuit amb
preferència a les corbes, veiem que el resultats són així:
33
SlotGen
Generador de circuits slot
En canvi, amb les mateixes pistes seleccionem que els circuits siguin més rectes, veiem
que la forma dels circuits generats no tenen tantes corbes:
El mètode de generació per bactracking és el menys fiable, ja que si posem massa pistes
correm el risc de no finalitzar mai el procés, però el sistema funciona correctament:
34
SlotGen
Generador de circuits slot
En cas de no trobar cap circuit, es mostra el logo del programa i a la barra de progrés
indica que el número de circuits trobats és zero.
L’aplicació disposa de diversos missatges de text emergents per ajudar l’usuari:
35
SlotGen
Generador de circuits slot
36
SlotGen
Generador de circuits slot
6- Conclusions
El programa creat, SlotGen, respon a les expectatives que s’havien marcat als objectius de
manera satisfactòria: d’una banda cobreix la manca de programes generadors de circuits, i
per l’altra, més personal però igualment important, em serveix particularment per la
necessitat que requeria, és a dir, tenir diferents circuits per muntar a partir de les meves
pistes de slot i de l’espai de què disposo.
A més, valoro molt positivament la part gràfica del programa, ja que crec que aporta
senzillesa i usabilitat, dues característiques que poden atreure l’atenció de possibles
usuaris.
Com a programa destinat a l’ús pràctic, la funcionalitat de generar tots els circuits
possibles no és molt útil. La seva implementació respon a criteris purament tècnics, per
dotar de qualitat el propi treball.
Altrament diré que m’ha suposat un esforç important poder implementar-la i que ha valgut
la pena aprofundir en l’algoritme de “tornada enrere”.
Pel que fa a les millores que es podrien aplicar, seria molt interessant que la generació dels
circuits es fes en multifil, per poder aprofitar tots els recursos de l’ordinador.
Finalment, crec que el futur de SlotGen passa per crear-ne una aplicació per a dispositius
mòbils (smartphone o tauleta). Seria desenvolupada amb Android, seguint la mateixa línia
conceptual que el programa creat, però més simplificat visualment. Crec que seria una
versió encara més pràctica i que, fins i tot comercialment , podria funcionar, encara que
s’hauria de valorar la potència que es necessita del dispositiu, amb el conseqüent
malbaratament de bateria que això provocaria.
37
SlotGen
Generador de circuits slot
7- Recursos utilitzats
7.1-
Bibliografia
API de java http://docs.oracle.com/javase/7/docs/api/
7.2-
Pàgines web
James, Michael. Is There Software to Help With Slot Car Track Design? About.com. s.f.
http://rcvehicles.about.com/od/slotcars/f/tracksoftware.htm (último acceso: 1 de
septiembre de 2014).
Navarro, Gabriel. «Teoría de Algoritmos. Tema 8. Diseño de Algoritmos: Backtracking.»
Teoría de Algoritmos. Universidad de Granada, Curso 2010-2011.
Ninco. s.f. www.ninco.co (último acceso: 1 de septiembre de 2014).
Rodríguez Carrión, Juan Gabriel (jgrc). «Tutorial de algoritmos en javascript, backtracking
recursivo: Cifras y letras.» Experimentando en la web. 13 de mayo de 2013.
http://www.jlabstudio.com/webgl/2013/05/tutorial-de-algoritmos-en-javascriptbacktracking-recursivo-cifras-y-letras/ (último acceso: 1 de septiembre de 2014).
Scalextric. s.f. http://www.scalextric.com/ (último acceso: 1 de septiembre de 2014).
Sergio Gálvez Rojas, Manuel Alcaide García, Miguel Ángel Mora Mata. Java a tope:
Java2D (Cómo tratar con java figuras, imágenes y texto en dos dimensiones).
Edición Electrónica. s.f.
Slot Adictos - Foro. s.f. http://slotadictos.mforos.com/ (último acceso: 1 de septiembre de
2014).
Stackoverflow. s.f. http://stackoverflow.com/ (último acceso: 1 de septiembre de 2014).
Tutorial Java2D. s.f. http://docs.oracle.com/javase/tutorial/2d/overview/.
Vecino de Casas, Carlos, Miguel Ángel Melón Pérez, y José Luis Redondo García. El
Esquema
Algorítmico
del
Backtracking.
s.f.
file:///C:/Documents%20and%20Settings/portatil/Mis%20documentos/Downloads/
backtracking.pdf (último acceso: 1 de septiembre de 2014).
Vuelta atrás. Wikipedia. s.f. http://es.wikipedia.org/wiki/Vuelta_atr%C3%A1s (último
acceso: 1 de septiembre de 2014).
7.3-
Programari
Slot Track Designer. © Mario Montiagudo Alda, 2001
Eclipse Java EE IDE (Versió Juno). © Eclipse contributors and other 2005,2012
Geogebra (Versió 4). Programari lliure
38
SlotGen
Generador de circuits slot
8- Annexes
8.1-
Instal·lació
Per poder executar el programa es necessita la màquina virtual de Java (JVM) instal·lada a
l’ordinador. Per l’execució del programa no cal fer cap instal·lació, només executar la
comanda java –jar SlotGen.jar o, si el SO té correctament associat el tipus de fitxer, fer
doble clic sobre el paquet jar.
8.2-
Requeriments
Sistema Operatiu:
-
Windows 7
Linux
MacOS
Qualsevol SO que accepti la instal·lació de la JVM en la versió 1.7
8.3-
Manual d’ús
8.3.1- Pantalla principal
Un cop s’ha executat l’arxiu del programa, es mostra la pantalla principal, des d’on es
configuren els criteris per procedir a la generació de circuits:





1
Introduir la quantitat de pistes de què es disposen, en els quadres de text del panell
de la dreta, segons els tipus1:
- Recta de 10 cm
- Recta de 20 cm
- Recta de 40 cm
- Corba Interior
- Corba Estàndard
- Corba Exterior
- Corba Super Exterior
Assegurar-se que com a mínim s’ha introduït una pista del tipus Recta de 40 cm
(pista on s’endollen els comandaments).
Especificar, si s’escau, la superfície màxima que pot arribar a ocupar el circuit.
Seleccionar el tipus de resultats desitjats:
o Aleatori: es farà una combinació de les pistes relativament aleatòria.
o Tots els circuits: es trobaran tots els circuits possibles segons les pistes
introduïdes.
o Traçat: desplaçant el control lliscant es regula si es vol un traçat amb més
corbes (sinuós) o amb més trams de rectes (recte).
Especificar el temps2 que es vol dedicar a la cerca, a través del control lliscant o bé
introduint-ho al quadre de text.
Aquests tipus corresponen al catàleg de productes de la marca comercial Ninco.
39
SlotGen
Generador de circuits slot



“Generar”, per iniciar el procés de generació.
“Detener”, per aturar el procés de generació
Fer clic sobre el resultat triat per veure’n els detalls.
Aquesta finestra romandrà oberta i mostrarà els resultats de la generació tot, i tenir una o
més finestres de detall obertes.
Els resultats de la generació poden variar encara que s’introdueixin els mateixos criteris ja
que el procés es basa en el factor aleatori i de probabilitat.
8.3.2- Pantalla de detall
Aquesta pantalla s’obre quan s’ha seleccionat un circuit concret:


Vista de la silueta del circuit: amb la roda del ratolí es pot ampliar o reduir la vista
del circuit seleccionat.
Informació que es mostra:
o Superfície: la disponible i la que ocupa el circuit en centímetres (amplada
cm x alçada cm)
o Recorreguts: el recorregut de cada carril i el recorregut mitjà en centímetres.
És important tenir en compte els diferents recorreguts de cada carril, per
aconseguir un recorregut equilibrat, o si més no, compensar-ho amb l’ús de
pistes que proporcionin un avantatge de velocitat segons traçat.
o Resum de pistes: taula per poder identificar les pistes en estoc.
 Pistes disponibles.
 Pistes usades per a la realització del circuit.
o Llistat de les pistes en ordre de col·locació i muntatge (en molts casos
caldrà usar la barra de desplaçament horitzontal per veure totes les pistes)
2
Per defecte la generació està estipulada en 3 segons.
40
SlotGen
Generador de circuits slot
8.4-
Índex de figures
Figura 1: Tipus de rectes ....................................................................................................... 5
Figura 2: Tipus de corbes ...................................................................................................... 5
Figura 3: Pantalla principal de l'aplicació ............................................................................. 6
Figura 4:Finestra de detall del circuit .................................................................................... 7
Figura 5: Esquema de la Recta 40 cm ................................................................................... 8
Figura 6: Esquema de la corba estàndard .............................................................................. 9
Figura 7: Unió de dues pistes corbes. .................................................................................. 10
Figura 8: Circuits equivalents .............................................................................................. 11
Figura 9: Circuits reflectits .................................................................................................. 12
Figura 10: Arbre de decisió backtracking............................................................................ 16
Figura 11: Circuit circular Geogebra ................................................................................... 18
Figura 12: Operació amb figures ......................................................................................... 19
Figura 13: UML representació de les pistes ........................................................................ 21
Figura 14: UML dibuix de les pistes ................................................................................... 22
Figura 15: UML mètodes de generació ............................................................................... 23
Figura 16: UML finestra principal....................................................................................... 24
Figura 17: UML esdeveniments finestra principal .............................................................. 25
Figura 18: UML esdeveniments panell resultats (miniatures)............................................. 26
Figura 19: UML finestra detall ............................................................................................ 27
Figura 20: UML esdeveniments de finestra detall............................................................... 28
41
SlotGen
Generador de circuits slot
9- Resum (Resumen/Abstract)
9.1-
Català
El programa creat amb motiu del Treball de Fi de Carrera que ens ocupa, consisteix en
l’elaboració d’una eina que generi de manera aleatòria una sèrie de possibles circuits slot a
partir de les pistes introduïdes per l’usuari, i segons una sèrie d’especificacions disponibles
per poder ajustar-la a les preferències desitjades, per tal d’obtenir el tipus de circuit més
adient a les condicions donades.
El funcionament s’inicia per part de l’usuari, qui ha d’indicar el número de pistes de què
disposa, a través de la finestra d’opcions situada a la part dreta. Pot elegir entre diversos
tipus de corbes i rectes, essent obligatori introduir com a mínim una recta de 40 cm (la
pista inicial on s’endollen els comandaments).
Una utilitat que fa més pràctic el generador , és l’especificació de la superfície disponible
per muntar el circuit. A més, l’usuari pot elegir el tipus de generació desitjada, això és,
pseudoaleatòria, amb discriminació segons una gradació del traçat (de més sinuós a més
recte) i la possibilitat de trobar tots els circuits que es poden generar amb les pistes
introduïdes. L’usuari també pot escollir la limitació temporal de la generació.
Finalment, un cop configurades les especificacions, es pot iniciar la generació de circuits
mitjançant el botó «Generar». També és possible aturar la generació en qualsevol moment
usant del botó «Detener».
A mesura que es van trobant circuits, la pantalla de resultats es va actualitzant. Quan la
generació de circuits ha acabat, es mostren tots els traçats obtinguts al panell principal i a
sota s’indica el nombre total de circuits obtinguts. Clicant sobre un resultat en concret,
s’obre una finestra externa amb els detalls del circuit i informació diversa per poder-lo
muntar:
-
Relació de les pistes en ordre de col·locació.
Resum de les pistes utilitzades i de les disponibles.
Silueta del circuit.
Mides de la superfície utilitzada.
Longitud del recorregut de cada carril.
El sistema que s’ha usat per configurar la funció aleatòria ha estat el d’atorgar a cada tipus
de pista una probabilitat d’esser utilitzada, proporcionalment corresponent a la quantitat de
pistes que representa respecte del total. Cal tenir en compte també, la feina de filtratge i
poda dels resultats per evitar duplicitats.
El més destacable del programa elaborat és l’avantatge que representa davant dels
programes de la mateixa categoria, la majoria destinats al disseny de circuits de forma
manual, amb què es perd l’ampli ventall de possibles creacions de traçats que ofereix
l’aleatorietat de SlotGen.
42
SlotGen
Generador de circuits slot
9.2-
Español
El programa creado con motivo del Trabajo de Fin de Carrera que nos ocupa, consiste en la
elaboración de una herramienta que genere de forma aleatoria una serie de posibles
circuitos slot a partir de las pistas introducidas por el usuario, y según una serie de
especificaciones disponibles para poder ajustarla a las preferencias deseadas, para así
obtener el tipo de circuito más adecuado para las condiciones dadas.
El funcionamiento se inicia por parte del usuario, quien debe indicar el número de pistas de
que dispone, a través de la ventana de opciones situada en la parte derecha. Puede elegir
entre varios tipos de curvas y rectas, siendo obligatorio introducir como mínimo una recta
de 40 cm (la pista inicial donde se enchufan los mandos), tal y como se indica en el
mensaje de error correspondiente.
Una utilidad que hace más práctico el generador es la especificación de la superficie
disponible para montar el circuito. Además, el usuario puede elegir el tipo de generación
deseada, esto es, seudoaleatoria, con discriminación según una gradación del trazado (de
más sinuoso a más rectilíneo) y la posibilidad de encontrar todos los circuitos que se
pueden generar con las pistas introducidas. El usuario también puede escoger la limitación
temporal de generación.
Finalmente, una vez configuradas las especificaciones, se puede iniciar la generación de
circuitos mediante el botón “Generar”. También es posible parar la generación en cualquier
momento usando el botón “Detener”.
A medida que se van encontrando circuitos, la pantalla de resultados se va actualizando.
Cuando la generación de circuitos ha acabado, se muestran todos los trazados obtenidos en
el panel principal y debajo se indica el número total de circuitos. Haciendo clic sobre uno
de los resultados en concreto, se abre una ventana externa con los detalles del circuito e
información variada para poderlo montar.
-
Relación de las pistas en orden de colocación.
Resumen de las pistas utilizadas y de las disponibles.
Silueta del circuito.
Medidas de la superficie utilizada.
Longitud del recorrido de cada carril.
El sistema que se ha usado para configurar la función aleatoria ha sido el de otorgar a cada
tipo de pista una probabilidad de ser usada, proporcionalmente correspondiente a la
cantidad de pistas que representa respecto del total. Merece mención también, el trabajo de
filtrado y poda de los resultados para evitar duplicidades.
El aspecto más destacable del programa elaborado es la ventaja que representa ante los
programas de la misma categoría, la mayoría destinados al diseño de circuitos de forma
manual, con los que se pierde el amplio abanico de posibles creaciones de trazados que
ofrece la aleatoriedad de SlotGen.
43
SlotGen
Generador de circuits slot
9.3-
English
The software created for the purpose of this Final Bachelor’s Work involves the
development of a tool that randomly generates a number of possible slot car circuits from
those tracks entered by the user, and according to a set of specifications available to, adjust
it to the desired preferences, so as to get the most appropriate circuit for the given
conditions.
The operation is initiated by the user, who must enter the number of tracks available,
through the Options window located on the right side. It can
choose from several
types of curves and straight tracks, being required to enter at least a straight of 40 cm (the
opening track where the controls are inserted), as indicated in the corresponding error
message.
The specification of the available surface for mounting the circuit has been implemented as
a utility that makes the generator more practical. In addition, the user can select the desired
type of generation, it is, pseudo-random search, or by discrimination as a scale of outline
shape (from more winding to more straight) and the possibility to find all the circuits that
can be generated with the introduced tracks. The user can also choose the time limitation
generation.
Finally, once configured those specifications, it can start generating circuits using the
"Generate" button. It is also possible to interrupt the generation at any time using the
"Stop" button.
As circuits are encountered, the results screen is updated. When generating circuits over,
all circuits obtained are shown in the main panel, and below it is shown the total number of
tracks. Clicking on one of the circuit opens an external window with the circuit details and
information to assemble it:
-
List of the tracks in order of placement.
Summary of tracks used and available.
Outline circuit.
Size of the surface used.
Length of the route of each lane.
To set the random function, it has been used a system that consists in giving each track
type a probability to be used according to the amount of tracks that represents over the
total. Also worth mentioning, the work of filtering and pruning of the results to avoid
duplication.
The highlight of the developed software is the advantage in front of other similar software
of the same category, most intended for manually circuit design, which lost the wide range
of possible creations paths offered by the randomness of SlotGen.
44
Descargar