Parasitas que me chupam!!!

Os parasitas tem sido um incomodo. Tenho trabalhado muito neste Natal e já superei minha marca de horas trabalhadas em um mês. Foram mais de 400 horas de trabalho em menos de 30 dias. Sem dúvida alguma, algo que tinha previsão de ser feito em três anos, por várias empresas e pessoas colaborando, ser feito no final das contas por uma única pessoa, um único desenvolvedor, e ser feito, em menos de 30 dias, é um grande feito. Para quem?! Deveria ser para mim, mas no que depender de parasitas, não será. Eu, sozinho e também por intermédio de minha empresa, a Solvoj, tenho prestado diferentes tipos de serviços ligados a GIS, desde 2005. De lá para cá, trabalhei com GPS, rastreadores veiculares, sistemas de rastreamento, mapas, etc, inclusive em 2005, começou a nascer o JBemTeVi que ficou pronto somente em 2006, após um ano inteiro de trabalho dedicado a ele e meu pedido de demissão da WeDo em janeiro de 2006, para que pudesse investir nesse produto. Ainda, desenvolvi aplicativos e utilitários para GPS e sistemas de rastreamento, com ou sem o JBemTeVi. Implementei visualizadores e componentes para diversos formatos cartográficos. E eis que tenho trabalhado como um burro de carga enquanto os carrapatos se lambuzam de meu sangue neste sol ardente do meu quarto aqui em Icarái, Niterói-RJ. Estou a uma quadra da praia e se esticar o pescoço para fora da janela, veria o mar, se não fosse uma árvore que tem a frente. No entanto, embalado por Ritalina, que me faz ter condições mentais de me concentrar na implementação deste meu produto, perco alguns quilogramas por não ter fome, pois meu único exercício tem sido o de paciência. Não saio de casa, apenas fico aqui, neste apartamento já imundo, trabalhando, trabalhando, para que outros, se apossem de minha virtude, de meu trabalho, de meu esforço, de meu tempo, de minha família, sem pagarem um puto por isso. Me pergunto como eu tenho a imensa capacidade em me deixar ser aproveitado. O pior, é que por ser um produto - não é de forma alguma um trabalho no qual vendo minhas horas, é um trabalho no qual desenvolvo um produto e vendo o direito de usarem esse meu produto em um produto interno deles, e deveria ser somente um produto interno deles, mas tenho motivos, razões suficientes, para acreditar que querem e estão determinados, a se apossarem de meu produto, como se fossem deles, mesmo não o sendo. E se tivessem a determinação de me pagarem por isso, por abrir mão do que é meu, tudo bem, se entrássemos em acordo, mas não, querem simplesmente me pagar por um pão, mas com o objetivo de se apossarem da padaria. Só tenho algo a dizer: NÂO VOU DEIXAR, NÃO DESSA VEZ, QUE FAÇAM ISSO! Posso ter trabalhado em vão durante esses seis meses e estou disposto a não receber um tostão por isso, mas não vão levar o que é meu sem pagarem o preço disso. Quer comprar a padaria? Eu vendo! Mas não pelo preço do pão! Aproveito, para deixar uma pequena contribuição, minha, antes que seja morto por parasitas. Segue:

  1 package net.marciowb.bemtevi.gui.layer.s57;
  2 
  3 import com.solvoj.S52Library.S52Catalog;
  4 import com.solvoj.S52Library.S52DisplayCategoryEnum;
  5 import com.solvoj.S52Library.S52ObjectSymbolization;
  6 import com.solvoj.S52Library.S52ObjectType;
  7 import com.solvoj.S52Library.S52PresentationEnum;
  8 import com.solvoj.S52Library.S57AttributeEnum;
  9 import com.solvoj.poison.io.FlatFloatBuffer;
 10 import com.solvoj.poison.util.ListUtil;
 11 import java.io.File;
 12 import java.io.Serializable;
 13 import java.util.ArrayList;
 14 import java.util.List;
 15 import java.util.logging.Level;
 16 import java.util.logging.Logger;
 17 import net.sourceforge.capcode.S57Library.basics.Link;
 18 import net.sourceforge.capcode.S57Library.basics.S57Pos2D;
 19 import net.sourceforge.capcode.S57Library.objects.S57Attribute;
 20 import net.sourceforge.capcode.S57Library.objects.S57Edge;
 21 import net.sourceforge.capcode.S57Library.objects.S57Feature;
 22 import net.sourceforge.capcode.S57Library.objects.S57IsolatedNode;
 23 import net.sourceforge.capcode.S57Library.objects.S57ModuleReader;
 24 import net.sourceforge.capcode.S57Library.objects.S57ObjectsVector;
 25 import net.sourceforge.capcode.S57Library.objects.S57Spatial;
 26 
 27 /**
 28  * A {@link S57ModuleReader} specialized to aid S52 presentations.
 29  * 
 30  * @see S52Catalog
 31  *
 32  * @author Marcio Wesley Borges, Niterói-RJ, 2010-12-10
 33  */
 34 public class S57S52ModuleReader extends S57ModuleReader<S57S52ModuleReader.S52LikeFeature> {
 35 
 36     private static final Logger logger = Logger.getLogger(S57S52ModuleReader.class.getName());
 37     public static final float DEG2RAD = (float) (1.0 / 180.0 * Math.PI);
 38     private final S52Context scat;
 39     private List<S52LikeFeature> symbolizedFeatures = new ArrayList<S52LikeFeature>(3000);
 40     private final boolean finestIsLoggable;
 41 
 42     public S57S52ModuleReader(S52Context scat, File file) {
 43         super(file);
 44         this.scat = scat;
 45         finestIsLoggable = logger.isLoggable(Level.FINEST);
 46     }
 47 
 48     @Override
 49     protected S52LikeFeature createFeature() {
 50         return new S52LikeFeature();
 51     }
 52 
 53     @Override
 54     public S57ObjectsVector<S52LikeFeature> getFeatures() {
 55         return super.getFeatures();
 56     }
 57 
 58     private S52PresentationEnum getPresentation(S52LikeFeature fe) {
 59         switch (fe.getPrimitive()) {
 60             case Area:
 61                 return scat.getBoundariesPresentation().getPresentation();
 62             case Line:
 63                 return S52PresentationEnum.LINES;
 64             case Point:
 65                 return scat.getPointsPresentation().getPresentation();
 66         }
 67         return null;
 68     }
 69 
 70 
 71     private void posProcessArea(S52LikeFeature fe) {
 72         int numInteriorCoords = 0;
 73         int numCoords = 0;
 74         int numCloseds = 0;
 75         boolean lastLinkIsClosed = true;
 76         S57Pos2D firstBeginInterior = null;
 77         S57Pos2D firstBegin = null;
 78         S57Pos2D firstEnd = null;
 79         S57Pos2D lastBegin = null;
 80         S57Pos2D lastEnd = null;
 81         Link lastLink = null;
 82         Link firstInteriorLink = null;
 83         for (Link link : fe.getSpatials()) {
 84             final S57Edge node = (S57Edge) link.spatial;
 85             if (node.hasAttributes()) {
 86                 for (S57Attribute a : node.getAttributes()) {
 87                     if (a.type == null) {
 88                         continue;
 89                     }
 90                     switch (a.type) {
 91                         case QUAPOS://TODO Exibir quality of pos, como necessário.
 92                             continue;
 93                         default:
 94                             logger.log(Level.WARNING, "Node {0} com atributo!", node);
 95                     }
 96                 }
 97             }
 98 
 99             int addittionalSize = 2;
100 
101             S57Pos2D begin = node.getBegin().getCoordinate();
102             S57Pos2D end = node.getEnd().getCoordinate();
103             if (link.isReversed()) {
104                 final S57Pos2D tmp = begin;
105                 begin = end;
106                 end = tmp;
107             }
108             if (firstBegin == null) {
109                 firstBegin = begin;
110             }
111             assert (link != firstInteriorLink) || lastLinkIsClosed;
112             if (lastEnd == begin) {
113                 //logger.info("lastEnd == begin");
114                 addittionalSize--;
115             } else {
116                 assert lastLinkIsClosed : "{lastLinkIsClosed}";
117             }
118             lastLinkIsClosed = false;
119             if (firstBegin == end) {
120                 //logger.info(begin==firstBegin ? "Self closed" : "Closed");
121                 lastLinkIsClosed = true;
122             }
123             if (lastLinkIsClosed) {
124                 lastBegin = null;
125                 lastEnd = null;
126                 firstBegin = null;
127                 numCloseds++;
128             } else {
129                 lastBegin = begin;
130                 lastEnd = end;
131                 lastLink = link;
132             }
133 
134             final int len = (node.getCoordinates().size() + addittionalSize);
135             if (link.isInterior()) {
136                 if (firstInteriorLink == null) {
137                     firstInteriorLink = link;
138                 }
139                 numInteriorCoords += len;
140             } else {
141                 numCoords += len;
142             }
143 
144             assert numCloseds <= 1 || link.isInterior() :
145                     "{numCloseds<=1 || link.isInterior()}: numCloseds=" + numCloseds;
146         }
147         // assert (firstBeginInterior!=null) || lastEnd.equals(firstBegin) : "{(firstBeginInterior!=null) || lastEnd.equals(firstBegin)}; firstBeginInterior:" + firstBeginInterior + "; lastEnd:"+lastEnd+"; firstBegin:" + firstBegin;
148         assert numCloseds <= fe.getSpatials().size() : "{numCloseds<=fe.getLinkToSpatials().size()}; numCloseds=" + numCloseds + "; fe.getLinkToSpatials().size()=" + fe.
149                 getSpatials().size();
150 
151         if (numCoords > 0 || numInteriorCoords > 0) {
152 
153             final FlatFloatBuffer bufCoords = new FlatFloatBuffer((numInteriorCoords + numCoords) * 2, numCloseds);
154 
155             lastLink = null;
156             lastBegin = null;
157             lastEnd = null;
158             firstBegin = null;
159             int idxCoord = 0;
160             float[] coords = null;
161             for (Link link : fe.getSpatials()) {
162 
163                 final S57Edge node = (S57Edge) link.spatial;
164                 final int numPositions = node.getCoordinates().size();
165 
166                 S57Pos2D begin = node.getBegin().getCoordinate();
167                 S57Pos2D end = node.getEnd().getCoordinate();
168 
169                 int inc = 1;
170                 int idxPos = 0;
171                 if (link.isReversed()) {
172                     final S57Pos2D tmp = begin;
173                     begin = end;
174                     end = tmp;
175                     inc = -1;
176                     idxPos = numPositions - 1;
177                 }
178 
179                 if (lastLinkIsClosed) {
180                     coords = bufCoords.add(idxCoord);
181                 }
182 
183                 boolean skipBegin = false;
184                 boolean skipEnd = false;
185 
186                 if (firstBegin == null) {
187                     firstBegin = begin;
188                 }
189                 assert (link != firstInteriorLink) || lastLinkIsClosed;
190                 if (lastEnd == begin) {
191                     //logger.info("lastEnd == begin");
192                     skipBegin = true;
193                 } else {
194                     assert lastLinkIsClosed : "{lastLinkIsClosed}";
195                 }
196                 lastLinkIsClosed = false;
197                 if (firstBegin == end) {
198                     //logger.info(begin==firstBegin ? "Self closed" : "Closed");
199                     lastLinkIsClosed = true;
200                 }
201                 if (lastLinkIsClosed) {
202                     lastBegin = null;
203                     lastEnd = null;
204                     firstBegin = null;
205                     numCloseds--;
206                 } else {
207                     lastBegin = begin;
208                     lastEnd = end;
209                     lastLink = link;
210                 }
211 
212                 if (!skipBegin) {
213                     coords[idxCoord++] = begin.latitude * DEG2RAD;
214                     coords[idxCoord++] = begin.longitude * DEG2RAD;
215                 }
216                 for (int i = 0; i < numPositions; i++) {
217                     final S57Pos2D pos = node.getCoordinates().get(idxPos);
218                     coords[idxCoord++] = pos.latitude * DEG2RAD;
219                     coords[idxCoord++] = pos.longitude * DEG2RAD;
220                     idxPos += inc;
221                 }
222                 if (!skipEnd) {
223                     coords[idxCoord++] = end.latitude * DEG2RAD;
224                     coords[idxCoord++] = end.longitude * DEG2RAD;
225                 }
226             }//end for Link
227             assert numCloseds == 0 : "{numCloseds==0}" + "; numCloseds:" + numCloseds;
228 
229             fe.coordinates = bufCoords;
230         }
231     }
232 
233     private void posProcessLine(S52LikeFeature fe) {
234         int numCoords = 0;
235         S57Pos2D firstBegin = null;
236         S57Pos2D firstEnd = null;
237         S57Pos2D lastBegin = null;
238         S57Pos2D lastEnd = null;
239         Link lastLink = null;
240 
241         for (Link link : fe.getSpatials()) {
242             final S57Edge node = (S57Edge) link.spatial;
243             if (node.hasAttributes()) {
244                 for (S57Attribute a : node.getAttributes()) {
245                     if (a.type == null) {
246                         continue;
247                     }
248                     switch (a.type) {
249                         case QUAPOS://TODO Exibir quality of pos, como necessário.
250                             continue;
251                         default:
252                             logger.log(Level.WARNING, "Node {0} com atributo!", node);
253                     }
254                 }
255             }
256 
257             int addittionalSize = 2;
258 
259             S57Pos2D begin = node.getBegin().getCoordinate();
260             S57Pos2D end = node.getEnd().getCoordinate();
261             if (link.isReversed()) {
262                 final S57Pos2D tmp = begin;
263                 begin = end;
264                 end = tmp;
265             }
266             if (firstBegin == null) {
267                 firstBegin = begin;
268             }
269             lastBegin = begin;
270             lastEnd = end;
271             lastLink = link;
272 
273             final int len = (node.getCoordinates().size() + addittionalSize);
274             numCoords += len;
275         }
276 
277         if (numCoords > 0) {
278 
279             final FlatFloatBuffer bufCoords = new FlatFloatBuffer(numCoords * 2, fe.getSpatials().size());
280             final float[] coords = bufCoords.add(0);
281             lastLink = null;
282             lastBegin = null;
283             lastEnd = null;
284             firstBegin = null;
285             int idxCoord = 0;
286             for (Link link : fe.getSpatials()) {
287 
288                 final S57Edge node = (S57Edge) link.spatial;
289                 final int numPositions = node.getCoordinates().size();
290 
291                 S57Pos2D begin = node.getBegin().getCoordinate();
292                 S57Pos2D end = node.getEnd().getCoordinate();
293 
294                 int inc = 1;
295                 int idxPos = 0;
296                 if (link.isReversed()) {
297                     final S57Pos2D tmp = begin;
298                     begin = end;
299                     end = tmp;
300                     inc = -1;
301                     idxPos = numPositions - 1;
302                 }
303 
304                 lastBegin = begin;
305                 lastEnd = end;
306                 lastLink = link;
307 
308                 coords[idxCoord++] = begin.latitude * DEG2RAD;
309                 coords[idxCoord++] = begin.longitude * DEG2RAD;
310                 for (int i = 0; i < numPositions; i++) {
311                     final S57Pos2D pos = node.getCoordinates().get(idxPos);
312                     coords[idxCoord++] = pos.latitude * DEG2RAD;
313                     coords[idxCoord++] = pos.longitude * DEG2RAD;
314                     idxPos += inc;
315                 }
316                 coords[idxCoord++] = end.latitude * DEG2RAD;
317                 coords[idxCoord++] = end.longitude * DEG2RAD;
318             }//end for Link
319 
320             fe.coordinates = bufCoords;
321         }
322     }
323 
324     private void posProcessPoint(final S52LikeFeature fe) {
325         int numCoords = 0;
326         for (Link link : fe.getSpatials()) {
327             if (!(link.spatial instanceof S57IsolatedNode)) {
328                 //logger.log(Level.WARNING, "Trate o link {0} de um feature do tipo ponto com espacial: {1}.", new Object[]{link, link.spatial});
329                 //continue;
330                 assert (!ListUtil.isEmpty(link.spatial.getCoordinates())) : link;
331             }
332             final S57Spatial node = link.spatial;
333             if (node.hasAttributes()) {
334                 for (S57Attribute a : node.getAttributes()) {
335                     if (a.type == null) {
336                         continue;
337                     }
338                     switch (a.type) {
339                         case QUAPOS://TODO Exibir quality of pos, como necessário.
340                             continue;
341                         default:
342                             logger.log(Level.WARNING, "Node {0} com atributo!", node);
343                     }
344                 }
345             }
346 
347             final int len = node.getCoordinates().size();
348             numCoords += len;
349         }
350 
351         if (numCoords > 0) {
352 
353             final FlatFloatBuffer bufCoords = new FlatFloatBuffer(numCoords * 2, fe.getSpatials().size());
354             final float[] coords = bufCoords.add(0);
355             int idxCoord = 0;
356             for (Link link : fe.getSpatials()) {
357                 final S57Spatial node = link.spatial;
358                 for (S57Pos2D pos: node.getCoordinates()) {
359                     coords[idxCoord++] = pos.latitude * DEG2RAD;
360                     coords[idxCoord++] = pos.longitude * DEG2RAD;
361                 }
362             }//end for Link
363 
364             fe.coordinates = bufCoords;
365         }
366     }
367 
368     private void posProcessSymbolization(final S52LikeFeature fe) {
369         fe.symbolization = null;
370         fe.priority = Integer.MIN_VALUE;
371         final S52PresentationEnum presentation = getPresentation(fe);
372         final S52DisplayCategoryEnum category = scat.getDisplayCategory();
373         for (S52ObjectSymbolization symb : fe.object.getSymbolizations(presentation, category)) {
374             if (fe.combines(symb)) {
375                 fe.symbolization = symb;
376 
377                 //Set Priority
378                 int priority = symb.priority * 100; //the default priority
379                 if (fe.isGroup1()) { // S57 group 1 filled areas
380                     priority+=10;
381                 } else if (fe.isArea()) {
382                     priority+=20;
383                 } else if (fe.isLine()) {
384                     priority+=30;
385                 } else if (fe.isPoint()) {
386                     priority+=40;
387                 }
388                 fe.priority = priority;
389 
390                 break;
391             }
392         }
393         if (finestIsLoggable) {
394             logger.log(Level.FINEST, "For the feature {0} the following symbolization matched: {1}.", new Object[]{fe, fe.symbolization});
395         }
396     }
397 
398     /**
399      * <p>4.7.2 Feature record to spatial record pointer field — use by line features
400      * In order to facilitate the decoding of linear features comprising multiple edges, the vector records
401      * making up the linear feature must be referenced sequentially.<br>
402      * The direction in which an edge is to be interpreted for a particular linear feature may be important
403      * (e.g. for the symbolization of non-symmetric line styles). In such cases the direction of
404      * interpretation is indicated in the ORNT subfield (see figure 4.1). Permissible values are:<br>
405      * F {1} Forward.<br>
406      * R {2} Reverse.<br>
407      * N {255} Direction is not relevant.</p>
408      *
409      * <p>The exterior boundary must be completely encoded before any interior boundaries and each interior
410      * boundary must be completed before encoding further interior boundaries.</p>
411      * 
412      */
413     @Override
414     protected void posProcessFeature(final S52LikeFeature fe) {
415         if (fe.object==null) {
416             final S52ObjectType obj = scat.getObject(fe.getType());
417             fe.object = obj;
418         }
419 
420         posProcessSymbolization(fe);
421         if (fe.symbolization == null) {
422             logger.log(Level.FINEST, "N\u00e3o foi encontrada simboliza\u00e7\u00e3o para {0}", fe);
423             return;
424         }
425 
426         if (fe.coordinates==null) {
427             if (fe.isArea()) {
428                 posProcessArea(fe);
429             } else if (fe.isLine()) {
430                 posProcessLine(fe);
431             } else if (fe.isPoint()) {
432                 posProcessPoint(fe);
433             }
434         }
435 
436         if (fe.coordinates!=null) {
437             symbolizedFeatures.add(fe);
438         }
439     }
440 
441     public List<S52LikeFeature> getSymbolizedFeatures() {
442         if (symbolizedFeatures.isEmpty()) {
443             for (S52LikeFeature fe: features) {
444                 posProcessFeature(fe);
445             }
446         }
447         return symbolizedFeatures;
448     }
449 
450     public void invalidateSymbolizedFeatures() {
451         symbolizedFeatures.clear();
452     }
453 
454     public class S52LikeFeature extends S57Feature {
455 
456         S52ObjectSymbolization symbolization;
457         S52ObjectType object;
458         FlatFloatBuffer coordinates;
459         int priority = Integer.MIN_VALUE;
460 
461         public float[] getEdgeCoordinates() {
462             return coordinates == null ? null : coordinates.getData();
463         }
464 
465         public boolean isAssHole() {
466             return coordinates != null && coordinates.count() > 1;
467         }
468 
469         public FlatFloatBuffer getCoordinates() {
470             return coordinates;
471         }
472 
473         public S52ObjectSymbolization getSymbolization() {
474             return symbolization;
475         }
476 
477         public S52ObjectType getObject() {
478             return object;
479         }
480 
481         boolean combines(final S52ObjectSymbolization symb) {
482             if (!symb.object.equals(object)) {
483                 return false;
484             }
485 
486             if (!symb.presentation.applies(primitive)) {
487                 return false;
488             }
489 
490             if (!symb.isCombined()) {
491                 return true;
492             }
493 
494             if (attributes == null) {
495                 return false;
496             }
497 
498             int numSymbAttributes = symb.combination.getAttributeCount();
499             if (attributes.size() < numSymbAttributes) {//Only continues if the feature has the same or more attributes than the symbolization rule.
500                 return false;
501             }
502 
503             for (S57Attribute a : attributes) {
504                 if (!symb.combination.hasAttribute(a.type)) {
505                     continue;
506                 }
507                 final Serializable value = a.getTypedValue();
508                 if (!symb.combination.anyCombination(a.type, value)) {
509                     return false;
510                 }
511                 if (--numSymbAttributes==0) {
512                     return true;
513                 }
514             }
515             return numSymbAttributes==0;
516         }
517 
518         public int getPriority() {
519             return priority;
520         }
521 
522         /**
523              * Build a list of "associated" DEPARE and DRGARE objects from a given
524               * object. to be "associated" means to be physically intersecting,
525               * overlapping, or contained within, depending upon the geometry type
526               * of the given object.
527         */
528         public List<S52LikeFeature> getAssociatedObjects() {
529               int j;
530               int disPrioIdx;
531 
532               final List<S52LikeFeature> pobj_list = new ArrayList<S52LikeFeature>();
533               pobj_list.clear();
534 
535               float lat, lon;
536               fromSM((obj->x * obj->x_rate) + obj->x_origin, (obj->y * obj->y_rate) + obj->y_origin, ref_lat, ref_lon, &lat, &lon);
537               //    What is the entry object geometry type?
538 
539               if (isPoint()) {
540                   ObjRazRules *top;
541                   disPrioIdx = 1;
542 
543                   for(j=0 ; j<LUPNAME_NUM ; j++)                   {
544 
545                         top = razRules[disPrioIdx][j];
546                         while ( top != NULL)                         {
547 
548                               if(!strncmp(top->obj->FeatureName, "DEPARE", 6) || !strncmp(top->obj->FeatureName, "DRGARE", 6)) {
549                                     if(obj->BBObj.PointInBox( lon, lat, 0.0))
550                                     {
551                                           if(IsPointInObjArea(lat, lon, 0.0, top->obj))
552                                               pobj_list.add(top->obj);
553                                     }
554                               }
555 
556                               ObjRazRules *nxx  = top->next;
557                               top = nxx;
558                         }
559                   }//end for
560             }//end if isPoint
561             return pobj_list;
562         }//end of method getAssociatedObjects
563 
564     }//end of class S52LikeFeature
565 
566 }//end of class S57S52ModuleReader
567 
568 
569