From: <dm...@us...> - 2007-04-10 18:03:35
|
Revision: 71 http://hugin.svn.sourceforge.net/hugin/?rev=71&view=rev Author: dmg Date: 2007-04-10 11:03:31 -0700 (Tue, 10 Apr 2007) Log Message: ----------- First commit Added Paths: ----------- libpanorama/trunk/src/parser/AUTHORS libpanorama/trunk/src/parser/COPYING libpanorama/trunk/src/parser/ChangeLog libpanorama/trunk/src/parser/Makefile.am libpanorama/trunk/src/parser/README.txt libpanorama/trunk/src/parser/parser.y libpanorama/trunk/src/parser/scanner.l libpanorama/trunk/src/parser/tparser.c libpanorama/trunk/src/parser/tparser.h Added: libpanorama/trunk/src/parser/AUTHORS =================================================================== --- libpanorama/trunk/src/parser/AUTHORS (rev 0) +++ libpanorama/trunk/src/parser/AUTHORS 2007-04-10 18:03:31 UTC (rev 71) @@ -0,0 +1 @@ +Daniel M. German - http://turingmachine.org/ Added: libpanorama/trunk/src/parser/COPYING =================================================================== --- libpanorama/trunk/src/parser/COPYING (rev 0) +++ libpanorama/trunk/src/parser/COPYING 2007-04-10 18:03:31 UTC (rev 71) @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + <one line to give the program's name and a brief idea of what it does.> + Copyright (C) <year> <name of author> + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + <signature of Ty Coon>, 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. Added: libpanorama/trunk/src/parser/ChangeLog =================================================================== --- libpanorama/trunk/src/parser/ChangeLog (rev 0) +++ libpanorama/trunk/src/parser/ChangeLog 2007-04-10 18:03:31 UTC (rev 71) @@ -0,0 +1,7 @@ +2007-04-10 dmg <dm...@uv...> + + * scanner.y, parser.l, tparser.h, tparser.c, README.txt, COPYING, + Makefile.am, ChangeLog, AUTHORS: First commit. Iimplement a simple + bison/yacc parser for the panotools/hugin scripts. + + Added: libpanorama/trunk/src/parser/Makefile.am =================================================================== --- libpanorama/trunk/src/parser/Makefile.am (rev 0) +++ libpanorama/trunk/src/parser/Makefile.am 2007-04-10 18:03:31 UTC (rev 71) @@ -0,0 +1,21 @@ +DEFAULT_INCLUDES="-I." + +BUILT_SOURCES = parser.h + +AM_YFLAGS = -d +AM_LFLAGS = -o$(LEX_OUTPUT_ROOT).c + +INCLUDES = -I${top_srcdir} + +AM_CPPFLAGS = $(LIN_DEFS) $(DAR_DEFS) +AM_LDFLAGS = -L${top_builddir} + +bin_PROGRAMS = Tparser + +Tparser_SOURCES = Tparser.c parser.y scanner.l parser.h tparser.h +Tparser_LDADD = -l${TLALILIB} -lfl -lm + +MAINTAINERCLEANFILES = \ + Makefile.in + + Added: libpanorama/trunk/src/parser/README.txt =================================================================== --- libpanorama/trunk/src/parser/README.txt (rev 0) +++ libpanorama/trunk/src/parser/README.txt 2007-04-10 18:03:31 UTC (rev 71) @@ -0,0 +1,42 @@ +Parser for panotools and hugin configuration scripts. + +Contents: + +* Usage +* Todo + + +---------------------------------------------------------------------- +USAGE: + +This bison/yacc parser implements a simple parser that reads a file +and converts it into an equivalent data structure. The main function +to use is: + + +pt_script *panoParseScript(char *filename) + + +It returns an allocated data structure pt_script. It should be +disposed properly using panoParseDispose. + + +void panoParseDispose(pt_script **scriptVar) + + +---------------------------------------------------------------------- +TODO: + +* Add support for K and V variables in hugin + +* Create a bunch of test cases + +* Create an include file for internal use, and one for exports. + +* Add support for en error function pointer so it can be replaced + +* Refactor the code to dump the data structure into a function that + can be used for debugging/testing + +* We need a function to verify that the read values are meaningful but + perhaps that is outside the scope of the parser. Added: libpanorama/trunk/src/parser/parser.y =================================================================== --- libpanorama/trunk/src/parser/parser.y (rev 0) +++ libpanorama/trunk/src/parser/parser.y 2007-04-10 18:03:31 UTC (rev 71) @@ -0,0 +1,418 @@ +/* + * parser.y + * + * Copyright Daniel M. German + * + * April 2007 + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this software; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Author: Daniel M German dmgerman at uvic doooot ca + * + */ + +%{ + #include <math.h> + #include <stdio.h> + #include <stdlib.h> + #include <string.h> + +#include "tparser.h" + + int yylex (void); + void yyerror (char const *); +/* Keeps track of the current type of input line in the file */ +int currentLine = -1; + +pt_script script; + +/* defining it gives better error messages. It might be an overkill */ +#define YYERROR_VERBOSE 1 + +static pt_script_image *image; + + +/* copy a string while allocating and checking for memory */ +static void ParserStringCopy(char **dest, char *from) +{ + if (*dest) + free(*dest); + *dest = strdup(from); + if (*dest == NULL) + panoParserError("Not enough memory"); +} + + +%} + +%defines + +%union { + int iVal; + float fVal; + char strVal[PT_TOKEN_MAX_LEN+1]; + char cVal; +} + + +%token NUM +%token PT_TOKEN_SEP +%token <iVal> PT_TOKEN_INT +%token <fVal> PT_TOKEN_FLOAT +%token <strVal> PT_TOKEN_STRING +%token <cVal> PT_TOKEN_KEYWORD +%token PT_TOKEN_EOL +%token PT_TOKEN_SEPARATOR +%token PT_TOKEN_INPUT_LINE +%token PT_TOKEN_OUTPUT_LINE +%token PT_TOKEN_PANO_LINE +%token PT_TOKEN_OPTIMIZE_LINE +%token PT_TOKEN_CONTROL_PTS_LINE +%token PT_TOKEN_COMMA +%token PT_TOKEN_REFERENCE + + +%start input + +%% /* Grammar rules and actions follow. */ + +input: lines + { return 0;} + +lines: + | line input +{ + printf("Per line...\n"); +} + +line: eoln { ; } + | inputline + | outputline + | panoline + | optimizeline + | PT_TOKEN_CONTROL_PTS_LINE PT_TOKEN_SEPARATOR vars eoln { ; } +; + +eoln: PT_TOKEN_EOL { currentLine = -1; /* This says we don't know the type of line being processed */} + +inputline: PT_TOKEN_INPUT_LINE PT_TOKEN_SEPARATOR + { + currentLine = PT_TOKEN_INPUT_LINE; + // allocate the new output + script.iInputImagesCount++; + script.inputImageSpec = realloc(script.inputImageSpec, + sizeof(*script.inputImageSpec) * script.iInputImagesCount); + if (script.inputImageSpec == NULL) { + yyerror("Not enough memory"); + } + image = &script.inputImageSpec[script.iInputImagesCount-1]; + } + vars eoln { ; } + +outputline: PT_TOKEN_OUTPUT_LINE PT_TOKEN_SEPARATOR + { + currentLine = PT_TOKEN_OUTPUT_LINE; + // allocate the new output + script.iOutputImagesCount++; + script.outputImageSpec = realloc(script.outputImageSpec, + sizeof(*script.outputImageSpec) * script.iOutputImagesCount); + if (script.outputImageSpec == NULL) { + yyerror("Not enough memory"); + } + image = &script.outputImageSpec[script.iOutputImagesCount-1]; + } vars eoln { ; } + +optimizeline: PT_TOKEN_OPTIMIZE_LINE PT_TOKEN_SEPARATOR { currentLine=PT_TOKEN_OPTIMIZE_LINE; } vars eoln { ; } + +panoline: PT_TOKEN_PANO_LINE PT_TOKEN_SEPARATOR { currentLine=PT_TOKEN_PANO_LINE; } vars eoln { ; } + + +vars: var + | vars PT_TOKEN_SEPARATOR var + +var: varparameter | varseveralparms | varreference + + + /* Rule for input image field references <var>=<index> */ +varreference: PT_TOKEN_KEYWORD PT_TOKEN_REFERENCE PT_TOKEN_INT + { + int imageRef = $3 + 1; + switch (currentLine) { + case PT_TOKEN_INPUT_LINE: + switch ($1) { + case 'v': + image->fHorFOVIndex = imageRef; + break; + case 'y': + image->yawIndex = imageRef; + break; + case 'p': + image->pitchIndex = imageRef; + break; + case 'r': + image->rollIndex = imageRef; + break; + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + image->coefIndex[$1-'a'] = imageRef; + break; + case 'g': + image->coefIndex[5] = imageRef; + break; + case 't': + image->coefIndex[6] = imageRef; + break; + default: + panoParserError("Invalid variable name [%c] in input line\n", $1); + return -1; + break; + } + break; + default: + panoParserError("Error Not handled 3 [%c]\n", $1); + return -1; + } + } + + /* Rule for [CS]<x>,<x>,<x>,<x> */ +varseveralparms: PT_TOKEN_KEYWORD PT_TOKEN_INT PT_TOKEN_COMMA PT_TOKEN_INT PT_TOKEN_COMMA PT_TOKEN_INT PT_TOKEN_COMMA PT_TOKEN_INT + { + switch (currentLine) { + case PT_TOKEN_OUTPUT_LINE: + case PT_TOKEN_INPUT_LINE: + switch ($1) { + case 'C': + case 'S': + image->cropType = $1; + image->cropArea[0] = $2; + image->cropArea[1] = $4; + image->cropArea[2] = $6; + image->cropArea[3] = $8; + break; + default: + panoParserError("Invalid variable name [%c] in image line\n", $1); + return -1; + } + break; + default: + panoParserError("Error Not handled 3\n"); + return -1; + } + } + +/* + Rules for <variable><parameter> + I repeat the processing of some variables in int and float type because I don't really know + how to deal with both data types in a simple rule as I don't want to always upgrade ints to floats. + */ +varparameter: PT_TOKEN_KEYWORD PT_TOKEN_STRING + { + /* Processing of string variables */ + switch (currentLine) { + case PT_TOKEN_PANO_LINE: + switch ($1) { + case 'f': + ParserStringCopy(&script.pano.projectionName, $2); + break; + case 'n': + ParserStringCopy(&script.pano.outputFormat, $2); + break; + case 'P': + ParserStringCopy(&script.pano.projectionParms, $2); + break; + default: + panoParserError("Invalid variable name [%c] in pano line\n", $1); + return -1; + } + break; + case PT_TOKEN_OUTPUT_LINE: + case PT_TOKEN_INPUT_LINE: + switch ($1) { + case 'n': + ParserStringCopy(&image->name, $2); + break; + default: + panoParserError("Invalid variable name [%c] in image line\n", $1); + return -1; + } + break; + default: + panoParserError("Error Not handled case [%c]\n", $1); + return -1; + } + } + | PT_TOKEN_KEYWORD PT_TOKEN_INT + { + /* Processing of int variables */ + switch (currentLine) { + case PT_TOKEN_PANO_LINE: + switch ($1) { + case 'w': + script.pano.width = $2; + break; + case 'h': + script.pano.height = $2; + break; + case 'f': + script.pano.projection = $2; + break; + case 'v': + script.pano.fHorFOV = $2; + break; + default: + panoParserError("Invalid variable name [%c] in pano line\n", $1); + return -1; + } + break; + case PT_TOKEN_OUTPUT_LINE: + case PT_TOKEN_INPUT_LINE: + switch ($1) { + case 'w': + image->width = $2; + break; + case 'h': + image->height = $2; + break; + case 'f': + image->projection = $2; + break; + case 'v': + image->fHorFOV = $2; + break; + case 'y': + image->yaw = $2; + break; + case 'p': + image->pitch = $2; + break; + case 'r': + image->roll = $2; + break; + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + image->coef[$1-'a'] = $2; + break; + case 'g': + image->coef[5] = $2; + break; + case 't': + image->coef[6] = $2; + break; + case 'u': + case 'm': + printf("Option %c in image line deprecated. \n", $1); + break; + default: + panoParserError("Invalid variable name [%c] in image line\n", $1); + return -1; + } + break; + case PT_TOKEN_OPTIMIZE_LINE: + switch ($1) { + case 'g': + script.optimize.fGamma = $2; + break; + case 'i': + script.optimize.interpolator = $2; + break; + case 'f': + script.optimize.fastFT = $2; + break; + case 'm': + script.optimize.humberEstimator = $2; + break; + default: + panoParserError("Invalid variable name [%c] in optimize line\n", $1); + return -1; + } + break; + default: + panoParserError("Error. Not handled (token int [%c]\n", $1); + return -1; + } + } + | PT_TOKEN_KEYWORD PT_TOKEN_FLOAT + { + /* Processing of float variables */ + switch (currentLine) { + case PT_TOKEN_PANO_LINE: + switch ($1) { + case 'v': + script.pano.fHorFOV = $2; + break; + default: + panoParserError("Invalid variable name [%c] in output line\n", $1); + return -1; + } + break; + case PT_TOKEN_OUTPUT_LINE: + case PT_TOKEN_INPUT_LINE: + switch ($1) { + case 'y': + image->yaw = $2; + break; + case 'p': + image->pitch = $2; + break; + case 'r': + image->roll = $2; + break; + case 'v': + image->fHorFOV = $2; + break; + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + image->coef[$1-'a'] = $2; + break; + case 'g': + image->coef[5] = $2; + break; + case 't': + image->coef[6] = $2; + break; + default: + panoParserError("Invalid variable name [%c] in pano line\n", $1); + return -1; + } + break; + case PT_TOKEN_OPTIMIZE_LINE: + switch ($1) { + case 'g': + script.optimize.fGamma = $2; + break; + default: + panoParserError("Invalid variable name [%c] in optimize line\n", $1); + return -1; + } + break; + default: + printf("Error Not handled 2 [%c]\n", $1); + return -1; + } + } + + + +%% Added: libpanorama/trunk/src/parser/scanner.l =================================================================== --- libpanorama/trunk/src/parser/scanner.l (rev 0) +++ libpanorama/trunk/src/parser/scanner.l 2007-04-10 18:03:31 UTC (rev 71) @@ -0,0 +1,227 @@ +/* + * scanner.h + * + * Copyright Daniel M. German + * + * April 2007 + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this software; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Author: Daniel M German dmgerman at uvic doooot ca + * + * This lex input file implements the panotools and hugin input scripts + * + * It ignores 'v' and 'c' lines: + * + * in 'i' lines it ignores 'K' and 'V' variables which are unique to hugin + * + */ + +%option noyywrap + +%{ +/* need this for the call to atof() below */ +#include <math.h> +#include <string.h> +#include "tparser.h" +#include "parser.h" +char strBuffer[PT_TOKEN_MAX_LEN+1]; +char *strBuffer_ptr; + +double ptTokenInt; +double ptTokenFloat; +char ptTokenLineType; +int inVariable = 0; + +#define YY_INPUT(buf,result,max_size) {\ + result = GetNextChar(buf, max_size); \ + if ( result <= 0 ) \ + result = YY_NULL; \ + } + +%} + +DIGIT [0-9] +LINETYPE [a-zA-Z] +ID [a-zA-Z] + +%x str +%x parm + + +%% + +-?{DIGIT}+ { + /* printf( "An integer: %s (%d)\n", yytext, atoi( yytext ) );*/ + panoScannerTokenBegin(yytext); + yylval.iVal = atoi( yytext ); + return PT_TOKEN_INT; + } + +-?{DIGIT}+"."{DIGIT}* { + /*printf( "A float: %s (%g)\n", yytext, atof( yytext ) );*/ + panoScannerTokenBegin(yytext); + yylval.fVal = atof( yytext ); + return PT_TOKEN_FLOAT; + } + +^[ \t]*\n { /* Ignore empty lines */ + inVariable = 0; + } + + +[ \t]*\n { /* END OF LINE is an important marker */ + /*printf( "End of line: %s\n", yytext );*/ + panoScannerTokenBegin(yytext); + return PT_TOKEN_EOL; + } + +<<EOF>> { + panoScannerTokenBegin(yytext); + return 0; + } + + + /* Tokens to ignore */ + +^v.*\n { ; } /* Ignore v lines */ + +^c.*\n { ; } /* Ignore c lines */ + +[KV][0-9A-Za-z.=-]+[ \t]* { ; } /* ignore K and V parameters */ + + + + /* These are the types of lines supported */ +^o { + panoScannerTokenBegin(yytext); + return PT_TOKEN_OUTPUT_LINE; + } + +^i { + panoScannerTokenBegin(yytext); + return PT_TOKEN_INPUT_LINE; + } + +^p { + panoScannerTokenBegin(yytext); + return PT_TOKEN_PANO_LINE; + } + +^m { + panoScannerTokenBegin(yytext); + return PT_TOKEN_OPTIMIZE_LINE; + } + +^C { + panoScannerTokenBegin(yytext); + return PT_TOKEN_CONTROL_PTS_LINE; + } + + /*********************************/ + +"," { + panoScannerTokenBegin(yytext); + return PT_TOKEN_COMMA; } + + +{ID} { + /*printf( "An identifier: %s\n", yytext );*/ + if (!inVariable) { + inVariable = 1; + panoScannerTokenBegin(yytext); + strncpy(yylval.strVal, yytext, PT_TOKEN_MAX_LEN); + return PT_TOKEN_KEYWORD; + } else { + /* Sometimes this correponds to the first char of + a parameter without quotes */ + BEGIN(parm); + strncpy(strBuffer, yytext, PT_TOKEN_MAX_LEN); + } + } + +<parm>[0-9a-zA-Z]+ { + /* Read the rest of the parameter */ + BEGIN(INITIAL); + inVariable = 0; + strncat(strBuffer, yytext, PT_TOKEN_MAX_LEN -1); + strncpy(yylval.strVal, strBuffer, PT_TOKEN_MAX_LEN); + return PT_TOKEN_STRING; + } + + +[ \t]+ { /*printf("skypping separator\n"); */ + panoScannerTokenBegin(yytext); + inVariable = 0; + return PT_TOKEN_SEPARATOR; + } + + += { + panoScannerTokenBegin(yytext); + return PT_TOKEN_REFERENCE; } + +"#".+\n /* eat up comments */ + { + ; + } + +\" { + panoScannerTokenBegin(yytext); + strBuffer_ptr = strBuffer; BEGIN(str); + //printf("Beginning of string\n"); + } + +<str>\" { /* saw closing quote - all done */ + BEGIN(INITIAL); + *strBuffer_ptr = '\0'; + /* return string constant token type and + * value to parser + */ + // printf("A string %s\n", strBuffer); + strncpy(yylval.strVal, strBuffer, PT_TOKEN_MAX_LEN); + return PT_TOKEN_STRING; + } + +<str>\n { + /* error - unterminated string constant */ + /* generate error message */ + panoParserError( "non-terminated string: %s\n", yytext ); + return -0; + } + +<str>\\n *strBuffer_ptr++ = '\n'; +<str>\\t *strBuffer_ptr++ = '\t'; +<str>\\r *strBuffer_ptr++ = '\r'; +<str>\\b *strBuffer_ptr++ = '\b'; +<str>\\f *strBuffer_ptr++ = '\f'; + +<str>\\(.|\n) *strBuffer_ptr++ = yytext[1]; + +<str>[^\\\n\"]+ { + int currentLen = strlen(strBuffer); + char *yptr = yytext; + while ( *yptr && ++currentLen < PT_TOKEN_MAX_LEN) + *strBuffer_ptr++ = *yptr++; + } + +. { + panoParserError( "Unrecognized character: %s\n", yytext ); + return 0; + } + +%% + Added: libpanorama/trunk/src/parser/tparser.c =================================================================== --- libpanorama/trunk/src/parser/tparser.c (rev 0) +++ libpanorama/trunk/src/parser/tparser.c 2007-04-10 18:03:31 UTC (rev 71) @@ -0,0 +1,334 @@ +/* + * tparser.c + * + * Copyright Daniel M. German + * + * April 2007 + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this software; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Author: Daniel M German dmgerman at uvic doooot ca + * + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <ctype.h> +#include <stdarg.h> +#include <assert.h> + +#include "tparser.h" +#include "parser.h" + + + +int debug; + +extern char *yytext; + +extern pt_script script; + +static FILE *file = NULL; +static int eof = 0; +static int nRow = 0; +static int nBuffer = 0; +static int lBuffer = 0; +static int nTokenStart = 0; +static int nTokenLength = 0; +static int nTokenNextStart = 0; +static int lMaxBuffer = PARSER_MAX_LINE; +static char buffer[PARSER_MAX_LINE+1]; + +char panoParserDumpChar(char c) +{ + if ( isprint(c) ) + return c; + return '@'; +} + +void panoParserDumpRow(void) +{ + fprintf(stdout, "%6d |%.*s", nRow, lBuffer, buffer); +} + +void panoParserError(char const *errorstring, ...) +{ + static char errmsg[1000]; + va_list args; + + int start=nTokenStart; + int end=start + nTokenLength - 1; + int i; + + panoParserDumpRow(); + + if ( eof ) { + fprintf(stdout, " !"); + for (i=0; i<lBuffer; i++) + fprintf(stdout, "."); + fprintf(stdout, "^-EOF\n"); + } else { + fprintf(stdout, " !"); + for (i=1; i<start; i++) + fprintf(stdout, "."); + for (i=start; i<=end; i++) + fprintf(stdout, "^"); + fprintf(stdout, " at line %d column %d\n", nRow, start); + } + + /* print it using variable arguments -----------------------------*/ + va_start(args, errorstring); + vsprintf(errmsg, errorstring, args); + va_end(args); + + fprintf(stdout, "Error: %s\n", errmsg); + + // exit +} + + +int getNextLine(void) +{ + char *p; + + nBuffer = 0; + nTokenStart = -1; + nTokenNextStart = 1; + eof = FALSE; + + p = fgets(buffer, lMaxBuffer, file); + if ( p == NULL ) { + if ( ferror(file) ) + return -1; + eof = TRUE; + return 1; + } + + nRow += 1; + lBuffer = strlen(buffer); + + return 0; +} + +// THis is the function that lex will use to read the next character +int GetNextChar(char *b, int maxBuffer) +{ + int frc; + + if ( eof ) + return 0; + + // read next line if at the end of the current + while ( nBuffer >= lBuffer ) { + frc = getNextLine(); + if ( frc != 0 ) + return 0; + } + + // ok, return character + b[0] = buffer[nBuffer]; + nBuffer += 1; + + if ( debug ) + printf("GetNextChar() => '%c'0x%02x at %d\n", + panoParserDumpChar(b[0]), b[0], nBuffer); + return b[0]==0?0:1; +} + +void panoScannerTokenBegin(char *t) +{ + // REcord where a token begins + nTokenStart = nTokenNextStart; + nTokenLength = strlen(t); + nTokenNextStart = nBuffer; // + 1; +} + + +void yyerror (char const *st) +{ + panoParserError(st); +} + +void panoParserDumpImage(pt_script_image *output) +{ + printf(" projection %d\n", output->projection); + printf(" width, height %dx%d ", output->width, output->height); + printf(" fHorFOV %f\n", output->fHorFOV); + printf(" yaw %f ", output->yaw); + printf(" pitch %f ", output->pitch); + printf(" roll %f ", output->roll); + + printf(" a %f", output->coef[0]); + printf(" b %f", output->coef[1]); + printf(" c %f", output->coef[2]); + printf(" d %f", output->coef[3]); + printf(" e %f", output->coef[4]); + printf(" g %f", output->coef[5]); + printf(" t %f\n", output->coef[6]); + + printf(" name %s\n", output->name); + printf(" cropType %d ", output->cropType); + printf(" cropArea %i,%i,%i,%i ", + output->cropArea[0], + output->cropArea[1], + output->cropArea[2], + output->cropArea[3]); + printf(" morphToFit %d\n", output->morphToFit); + + printf(" References: "); + printf(" fHorFOV %d", output->fHorFOVIndex); + printf(" yaw %d", output->yawIndex); + printf(" pitch %d", output->pitchIndex); + printf(" roll %d", output->rollIndex); + + printf(" a %d", output->coefIndex[0]); + printf(" b %d", output->coefIndex[1]); + printf(" c %d", output->coefIndex[2]); + printf(" d %d", output->coefIndex[3]); + printf(" e %d", output->coefIndex[4]); + printf(" g %d", output->coefIndex[5]); + printf(" t %d\n", output->coefIndex[6]); + +} + +int panoParseReset(void) +{ + if (file != NULL) + return FALSE; + /* There should not be anything allocated in script */ + bzero(&script, sizeof(script)); + return 1; +} + + +pt_script *panoParseScript(char *filename) +{ + pt_script *scriptVar; + if (!panoParseReset() ) { + // This is really an assertion + fprintf(stderr, "This parser is not reentrant"); + exit(1); + } + file = fopen(filename, "r"); + if ( file == NULL ) { + return NULL; + } + if ( getNextLine() == 0 ) { + if (yyparse() ==0) { + // duplicate data structure to return + scriptVar = calloc(1, sizeof(*scriptVar)); + if (scriptVar == NULL) { + PrintError("Not enough memory"); + return NULL; + } + // Just making sure.. + assert(sizeof(*scriptVar) == sizeof(*scriptVar)); + memcpy(scriptVar, &script, sizeof(*scriptVar)); + return scriptVar; + } else { + return FALSE; + } + + } + else { + PrintError("Input file is empty"); + return NULL; + } + close (file); + +} + +void panoParseDispose(pt_script **scriptVar) +{ + int i; + // free all the data structures in it before freeing the variable itself + +#define FREE(a) ((a) != NULL, free(a)) + pt_script *ptr = *scriptVar; + + // Free pt_script_pano first + FREE(ptr->pano.projectionParms); + + FREE(ptr->pano.outputFormat); + + for (i=0;i<ptr->iOutputImagesCount;i++) { + FREE(ptr->outputImageSpec[i].name); + } + for (i=0;i<ptr->iInputImagesCount;i++) { + FREE(ptr->inputImageSpec[i].name); + } + FREE(ptr->outputImageSpec); + FREE(ptr->inputImageSpec); + FREE(ptr->morphingPointsSpec); + +#undef FREE + + free(ptr); + *scriptVar = NULL; +} + + + +int main(int argc, char *argv[]) +{ + int i; + + pt_script_image *output; + pt_script *script = NULL; + + script = panoParseScript(argv[1]); + + if (script == NULL) { + printf("Parsing error\n"); + return 1; + } + + + printf("Values\n"); + printf("Pano ................."); + printf(" width,height %dx%d ", script->pano.width, script->pano.height); + printf(" projection %d ", script->pano.projection); + printf(" name %s ", script->pano.projectionName); + printf(" fHorFOV %f ", script->pano.fHorFOV); + printf(" format %s ", script->pano.outputFormat); + printf(" proj parms %s\n", script->pano.projectionParms); + + printf("Optimize .................."); + printf(" gamma %f", script->optimize.fGamma); + printf(" interpolator %d", script->optimize.interpolator); + printf(" fastFT %d ", script->optimize.fastFT); + printf(" humber %d \n", script->optimize.humberEstimator); + + printf("Output [%d] images ..................\n", script->iOutputImagesCount); + + for (i=0;i<script->iOutputImagesCount;i++) { + output = &script->outputImageSpec[i]; + printf(" image %d\n", i); + panoParserDumpImage(output); + } + printf("Input [%d] images ..................\n", script->iInputImagesCount); + + for (i=0;i<script->iInputImagesCount;i++) { + output = &script->inputImageSpec[i]; + printf(" image %d\n", i); + panoParserDumpImage(output); + } + + panoParseDispose(&script); + + return 0; +} Added: libpanorama/trunk/src/parser/tparser.h =================================================================== --- libpanorama/trunk/src/parser/tparser.h (rev 0) +++ libpanorama/trunk/src/parser/tparser.h 2007-04-10 18:03:31 UTC (rev 71) @@ -0,0 +1,102 @@ +/* + * tparser.h + * + * Copyright Daniel M. German + * + * April 2007 + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this software; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Author: Daniel M German dmgerman at uvic doooot ca + * + */ + + +/* Maximum size for an input token */ +#define PARSER_MAX_LINE 1000 +#define PT_TOKEN_MAX_LEN PARSER_MAX_LINE + +/* + Data structure where the entire input file will be read +*/ + +#define FALSE 0 +#define TRUE 0 + + +typedef struct { + int width; + int height; + int projection; + char *projectionParms; + char *projectionName; + float fHorFOV; + char *outputFormat; +} pt_script_pano; + +typedef struct { + int projection; + int width; + int height; + float fHorFOV; + float yaw; + float pitch; + float roll; + float coef[7]; // a, b, c, d, e , g, t + char *name; + int cropType ; + int cropArea[4]; + int morphToFit; + // pointers to variable if they are used. + // For the sake of simplicity they start at 1, if they are zero they are unused + int fHorFOVIndex; + int yawIndex; + int pitchIndex; + int rollIndex; + int coefIndex[7]; // a, b, c, d, e , g, t +} pt_script_image; + +typedef struct { + int iImage; + float x1, y1, x2, y2; +} pt_script_morphing_points; + +typedef struct { + float fGamma; + int interpolator; + int fastFT; + int humberEstimator; +} pt_script_optimize; + +typedef struct { + pt_script_pano pano; + int iInputImagesCount; + pt_script_image *inputImageSpec; + int iOutputImagesCount; + pt_script_image *outputImageSpec; + pt_script_morphing_points *morphingPointsSpec; + pt_script_optimize optimize; +} pt_script; + +pt_script *Read_Script(char *fileName); + + +void TokenBegin(char *t) ; +int GetNextChar(char *b, int maxBuffer) ; +void Parse_Error(char const *errorstring, ...) ; + + + This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dm...@us...> - 2007-04-18 16:28:09
|
Revision: 73 http://hugin.svn.sourceforge.net/hugin/?rev=73&view=rev Author: dmg Date: 2007-04-18 09:28:05 -0700 (Wed, 18 Apr 2007) Log Message: ----------- 2007-04-18 dmg <dm...@uv...> > > * tparser.c, tparser.h: Renamed some functions to the tlalli naming > standards. Added functions to parse projection parameters. Added > functions to de-reference variables. Added a function to dump the > content of the script variable. Fixed some bugs. > > * tparserprivate.h: Added this file to keep any declarations that > are only required to by parser. > > * parser.y: Clear newly allocated memory for image specs > > * testparser.c: Added logic to dereference variables. Moved > dumping of variables to a function in tparser.c > > Modified Paths: -------------- libpanorama/trunk/src/parser/CMakeLists.txt libpanorama/trunk/src/parser/ChangeLog libpanorama/trunk/src/parser/parser.y libpanorama/trunk/src/parser/scanner.l libpanorama/trunk/src/parser/testparser.c libpanorama/trunk/src/parser/tparser.c libpanorama/trunk/src/parser/tparser.h Added Paths: ----------- libpanorama/trunk/src/parser/tparserprivate.h Modified: libpanorama/trunk/src/parser/CMakeLists.txt =================================================================== --- libpanorama/trunk/src/parser/CMakeLists.txt 2007-04-11 09:45:53 UTC (rev 72) +++ libpanorama/trunk/src/parser/CMakeLists.txt 2007-04-18 16:28:05 UTC (rev 73) @@ -6,8 +6,8 @@ #ADD_FLEX_BISON_DEPENDENCY(scanner parser) -ADD_CUSTOM_COMMAND(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/parser.c - COMMAND ${BISON_EXECUTABLE} -oparser.c ${CMAKE_CURRENT_SOURCE_DIR}/parser.y +ADD_CUSTOM_COMMAND(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/parser.c ${CMAKE_CURRENT_BINARY_DIR}/parser.h + COMMAND ${BISON_EXECUTABLE} -d -oparser.c ${CMAKE_CURRENT_SOURCE_DIR}/parser.y DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/parser.y ) ADD_CUSTOM_COMMAND(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/scanner.c Modified: libpanorama/trunk/src/parser/ChangeLog =================================================================== --- libpanorama/trunk/src/parser/ChangeLog 2007-04-11 09:45:53 UTC (rev 72) +++ libpanorama/trunk/src/parser/ChangeLog 2007-04-18 16:28:05 UTC (rev 73) @@ -1,5 +1,21 @@ -2007-04-11 dmg <pab...@we...> +2007-04-18 dmg <dm...@uv...> + * tparser.c, tparser.h: Renamed some functions to the tlalli naming + standards. Added functions to parse projection parameters. Added + functions to de-reference variables. Added a function to dump the + content of the script variable. Fixed some bugs. + + * tparserprivate.h: Added this file to keep any declarations that + are only required to by parser. + + * parser.y: Clear newly allocated memory for image specs + + * testparser.c: Added logic to dereference variables. Moved + dumping of variables to a function in tparser.c + + +2007-04-11 pablo <pab...@we...> + * CMakeLists.txt, CMakeModules/FindBISON.cmake, CMakeModules/FindFLEX.cmake, src/CMakeLists.txt, src/parser/CMakeLists.txt: CMake based build system Modified: libpanorama/trunk/src/parser/parser.y =================================================================== --- libpanorama/trunk/src/parser/parser.y 2007-04-11 09:45:53 UTC (rev 72) +++ libpanorama/trunk/src/parser/parser.y 2007-04-18 16:28:05 UTC (rev 73) @@ -31,6 +31,7 @@ #include <string.h> #include "tparser.h" +#include "tparserprivate.h" int yylex (void); void yyerror (char const *); @@ -52,7 +53,7 @@ free(*dest); *dest = strdup(from); if (*dest == NULL) - panoParserError("Not enough memory"); + panoScriptParserError("Not enough memory"); } @@ -118,6 +119,8 @@ if (script.inputImageSpec == NULL) { yyerror("Not enough memory"); } + // clear the end of the reallocated region + bzero(&(script.inputImageSpec[script.iInputImagesCount-1]), sizeof(*script.inputImageSpec)); image = &script.inputImageSpec[script.iInputImagesCount-1]; } vars eoln { ; } @@ -132,6 +135,8 @@ if (script.outputImageSpec == NULL) { yyerror("Not enough memory"); } + // clear the end of the reallocated region + bzero(&(script.outputImageSpec[script.iOutputImagesCount-1]), sizeof(*script.outputImageSpec)); image = &script.outputImageSpec[script.iOutputImagesCount-1]; } vars eoln { ; } @@ -179,13 +184,13 @@ image->coefIndex[6] = imageRef; break; default: - panoParserError("Invalid variable name [%c] in input line\n", $1); + panoScriptParserError("Invalid variable name [%c] in input line\n", $1); return -1; break; } break; default: - panoParserError("Error Not handled 3 [%c]\n", $1); + panoScriptParserError("Error Not handled 3 [%c]\n", $1); return -1; } } @@ -206,12 +211,12 @@ image->cropArea[3] = $8; break; default: - panoParserError("Invalid variable name [%c] in image line\n", $1); + panoScriptParserError("Invalid variable name [%c] in image line\n", $1); return -1; } break; default: - panoParserError("Error Not handled 3\n"); + panoScriptParserError("Error Not handled 3\n"); return -1; } } @@ -234,10 +239,10 @@ ParserStringCopy(&script.pano.outputFormat, $2); break; case 'P': - ParserStringCopy(&script.pano.projectionParms, $2); + ParserStringCopy(&script.pano.projectionParmsString, $2); break; default: - panoParserError("Invalid variable name [%c] in pano line\n", $1); + panoScriptParserError("Invalid variable name [%c] in pano line\n", $1); return -1; } break; @@ -248,12 +253,12 @@ ParserStringCopy(&image->name, $2); break; default: - panoParserError("Invalid variable name [%c] in image line\n", $1); + panoScriptParserError("Invalid variable name [%c] in image line\n", $1); return -1; } break; default: - panoParserError("Error Not handled case [%c]\n", $1); + panoScriptParserError("Error Not handled case [%c]\n", $1); return -1; } } @@ -276,7 +281,7 @@ script.pano.fHorFOV = $2; break; default: - panoParserError("Invalid variable name [%c] in pano line\n", $1); + panoScriptParserError("Invalid variable name [%c] in pano line\n", $1); return -1; } break; @@ -322,7 +327,7 @@ printf("Option %c in image line deprecated. \n", $1); break; default: - panoParserError("Invalid variable name [%c] in image line\n", $1); + panoScriptParserError("Invalid variable name [%c] in image line\n", $1); return -1; } break; @@ -341,12 +346,12 @@ script.optimize.humberEstimator = $2; break; default: - panoParserError("Invalid variable name [%c] in optimize line\n", $1); + panoScriptParserError("Invalid variable name [%c] in optimize line\n", $1); return -1; } break; default: - panoParserError("Error. Not handled (token int [%c]\n", $1); + panoScriptParserError("Error. Not handled (token int [%c]\n", $1); return -1; } } @@ -360,7 +365,7 @@ script.pano.fHorFOV = $2; break; default: - panoParserError("Invalid variable name [%c] in output line\n", $1); + panoScriptParserError("Invalid variable name [%c] in output line\n", $1); return -1; } break; @@ -393,7 +398,7 @@ image->coef[6] = $2; break; default: - panoParserError("Invalid variable name [%c] in pano line\n", $1); + panoScriptParserError("Invalid variable name [%c] in pano line\n", $1); return -1; } break; @@ -403,7 +408,7 @@ script.optimize.fGamma = $2; break; default: - panoParserError("Invalid variable name [%c] in optimize line\n", $1); + panoScriptParserError("Invalid variable name [%c] in optimize line\n", $1); return -1; } break; Modified: libpanorama/trunk/src/parser/scanner.l =================================================================== --- libpanorama/trunk/src/parser/scanner.l 2007-04-11 09:45:53 UTC (rev 72) +++ libpanorama/trunk/src/parser/scanner.l 2007-04-18 16:28:05 UTC (rev 73) @@ -37,7 +37,9 @@ #include <math.h> #include <string.h> #include "tparser.h" +#include "tparserprivate.h" #include "parser.h" + char strBuffer[PT_TOKEN_MAX_LEN+1]; char *strBuffer_ptr; @@ -47,7 +49,7 @@ int inVariable = 0; #define YY_INPUT(buf,result,max_size) {\ - result = GetNextChar(buf, max_size); \ + result = panoScriptScannerGetNextChar(buf, max_size); \ if ( result <= 0 ) \ result = YY_NULL; \ } @@ -66,14 +68,14 @@ -?{DIGIT}+ { /* printf( "An integer: %s (%d)\n", yytext, atoi( yytext ) );*/ - panoScannerTokenBegin(yytext); + panoScriptScannerTokenBegin(yytext); yylval.iVal = atoi( yytext ); return PT_TOKEN_INT; } -?{DIGIT}+"."{DIGIT}* { /*printf( "A float: %s (%g)\n", yytext, atof( yytext ) );*/ - panoScannerTokenBegin(yytext); + panoScriptScannerTokenBegin(yytext); yylval.fVal = atof( yytext ); return PT_TOKEN_FLOAT; } @@ -85,12 +87,12 @@ [ \t]*\n { /* END OF LINE is an important marker */ /*printf( "End of line: %s\n", yytext );*/ - panoScannerTokenBegin(yytext); + panoScriptScannerTokenBegin(yytext); return PT_TOKEN_EOL; } <<EOF>> { - panoScannerTokenBegin(yytext); + panoScriptScannerTokenBegin(yytext); return 0; } @@ -107,34 +109,34 @@ /* These are the types of lines supported */ ^o { - panoScannerTokenBegin(yytext); + panoScriptScannerTokenBegin(yytext); return PT_TOKEN_OUTPUT_LINE; } ^i { - panoScannerTokenBegin(yytext); + panoScriptScannerTokenBegin(yytext); return PT_TOKEN_INPUT_LINE; } ^p { - panoScannerTokenBegin(yytext); + panoScriptScannerTokenBegin(yytext); return PT_TOKEN_PANO_LINE; } ^m { - panoScannerTokenBegin(yytext); + panoScriptScannerTokenBegin(yytext); return PT_TOKEN_OPTIMIZE_LINE; } ^C { - panoScannerTokenBegin(yytext); + panoScriptScannerTokenBegin(yytext); return PT_TOKEN_CONTROL_PTS_LINE; } /*********************************/ "," { - panoScannerTokenBegin(yytext); + panoScriptScannerTokenBegin(yytext); return PT_TOKEN_COMMA; } @@ -142,7 +144,7 @@ /*printf( "An identifier: %s\n", yytext );*/ if (!inVariable) { inVariable = 1; - panoScannerTokenBegin(yytext); + panoScriptScannerTokenBegin(yytext); strncpy(yylval.strVal, yytext, PT_TOKEN_MAX_LEN); return PT_TOKEN_KEYWORD; } else { @@ -164,14 +166,14 @@ [ \t]+ { /*printf("skypping separator\n"); */ - panoScannerTokenBegin(yytext); + panoScriptScannerTokenBegin(yytext); inVariable = 0; return PT_TOKEN_SEPARATOR; } = { - panoScannerTokenBegin(yytext); + panoScriptScannerTokenBegin(yytext); return PT_TOKEN_REFERENCE; } "#".+\n /* eat up comments */ @@ -180,7 +182,7 @@ } \" { - panoScannerTokenBegin(yytext); + panoScriptScannerTokenBegin(yytext); strBuffer_ptr = strBuffer; BEGIN(str); //printf("Beginning of string\n"); } @@ -199,7 +201,7 @@ <str>\n { /* error - unterminated string constant */ /* generate error message */ - panoParserError( "non-terminated string: %s\n", yytext ); + panoScriptParserError( "non-terminated string: %s\n", yytext ); return -0; } @@ -219,7 +221,7 @@ } . { - panoParserError( "Unrecognized character: %s\n", yytext ); + panoScriptParserError( "Unrecognized character: %s\n", yytext ); return 0; } Modified: libpanorama/trunk/src/parser/testparser.c =================================================================== --- libpanorama/trunk/src/parser/testparser.c 2007-04-11 09:45:53 UTC (rev 72) +++ libpanorama/trunk/src/parser/testparser.c 2007-04-18 16:28:05 UTC (rev 73) @@ -38,48 +38,27 @@ { int i; - pt_script_image *output; pt_script *script = NULL; - script = panoParseScript(argv[1]); + printf("Testing parser for panotools and hugin files\n"); + + script = panoScriptParse(argv[1], FALSE); if (script == NULL) { printf("Parsing error\n"); - return 1; - } + } else { + panoScriptDump(script); - - printf("Values\n"); - printf("Pano ................."); - printf(" width,height %dx%d ", script->pano.width, script->pano.height); - printf(" projection %d ", script->pano.projection); - printf(" name %s ", script->pano.projectionName); - printf(" fHorFOV %f ", script->pano.fHorFOV); - printf(" format %s ", script->pano.outputFormat); - printf(" proj parms %s\n", script->pano.projectionParms); - - printf("Optimize .................."); - printf(" gamma %f", script->optimize.fGamma); - printf(" interpolator %d", script->optimize.interpolator); - printf(" fastFT %d ", script->optimize.fastFT); - printf(" humber %d \n", script->optimize.humberEstimator); - - printf("Output [%d] images ..................\n", script->iOutputImagesCount); - - for (i=0;i<script->iOutputImagesCount;i++) { - output = &script->outputImageSpec[i]; - printf(" image %d\n", i); - panoParserDumpImage(output); - } - printf("Input [%d] images ..................\n", script->iInputImagesCount); + if (!panoScriptDeReferenceVariables(script)) { + printf("Unable to de-reference all variable\n"); + } + + printf("Printing after variables are dereferrenced\n"); - for (i=0;i<script->iInputImagesCount;i++) { - output = &script->inputImageSpec[i]; - printf(" image %d\n", i); - panoParserDumpImage(output); + panoScriptDump(script); + + panoParserDispose(&script); } - panoParseDispose(&script); - return 0; } Modified: libpanorama/trunk/src/parser/tparser.c =================================================================== --- libpanorama/trunk/src/parser/tparser.c 2007-04-11 09:45:53 UTC (rev 72) +++ libpanorama/trunk/src/parser/tparser.c 2007-04-18 16:28:05 UTC (rev 73) @@ -34,8 +34,8 @@ #include "tparser.h" #include "parser.h" +int yyparse(void) ; - int debug; extern char *yytext; @@ -53,24 +53,20 @@ static int lMaxBuffer = PARSER_MAX_LINE; static char buffer[PARSER_MAX_LINE+1]; -void panoPrintError(const char * c) -{ - fprintf(stderr,"%s\n",c); -} -char panoParserDumpChar(char c) +char panoScriptParserDumpChar(char c) { if ( isprint(c) ) return c; return '@'; } -void panoParserDumpRow(void) +void panoScriptParserDumpRow(void) { fprintf(stdout, "%6d |%.*s", nRow, lBuffer, buffer); } -void panoParserError(char const *errorstring, ...) +void panoScriptParserError(char const *errorstring, ...) { static char errmsg[1000]; va_list args; @@ -79,7 +75,7 @@ int end=start + nTokenLength - 1; int i; - panoParserDumpRow(); + panoScriptParserDumpRow(); if ( eof ) { fprintf(stdout, " !"); @@ -106,7 +102,7 @@ } -int getNextLine(void) +int panoScriptScannerGetNextLine(void) { char *p; @@ -130,7 +126,7 @@ } // THis is the function that lex will use to read the next character -int GetNextChar(char *b, int maxBuffer) +int panoScriptScannerGetNextChar(char *b, int maxBuffer) { int frc; @@ -139,7 +135,7 @@ // read next line if at the end of the current while ( nBuffer >= lBuffer ) { - frc = getNextLine(); + frc = panoScriptScannerGetNextLine(); if ( frc != 0 ) return 0; } @@ -150,11 +146,11 @@ if ( debug ) printf("GetNextChar() => '%c'0x%02x at %d\n", - panoParserDumpChar(b[0]), b[0], nBuffer); + panoScriptParserDumpChar(b[0]), b[0], nBuffer); return b[0]==0?0:1; } -void panoScannerTokenBegin(char *t) +void panoScriptScannerTokenBegin(char *t) { // REcord where a token begins nTokenStart = nTokenNextStart; @@ -165,7 +161,7 @@ void yyerror (char const *st) { - panoParserError(st); + panoScriptParserError(st); } void panoParserDumpImage(pt_script_image *output) @@ -210,20 +206,166 @@ } -int panoParseReset(void) +void panoScriptDump(pt_script *script) { - if (file != NULL) + int i; + pt_script_image *output; + + assert(script != NULL); + + printf("Values\n"); + printf("Pano ................."); + printf(" width,height %dx%d ", script->pano.width, script->pano.height); + printf(" projection %d ", script->pano.projection); + printf(" name %s ", script->pano.projectionName); + printf(" fHorFOV %f ", script->pano.fHorFOV); + printf(" format %s ", script->pano.outputFormat); + printf(" proj parms %s\n", script->pano.projectionParmsString); + printf(" proj parms count %d\n", script->pano.projectionParmsCount); + for (i=0;i<script->pano.projectionParmsCount;i++) { + printf(" proj parm %d: %f\n", i, script->pano.projectionParms[i]); + } + + printf("Optimize .................."); + printf(" gamma %f", script->optimize.fGamma); + printf(" interpolator %d", script->optimize.interpolator); + printf(" fastFT %d ", script->optimize.fastFT); + printf(" humber %d \n", script->optimize.humberEstimator); + + printf("Output [%d] images ..................\n", script->iOutputImagesCount); + + for (i=0;i<script->iOutputImagesCount;i++) { + output = &script->outputImageSpec[i]; + printf(" image %d\n", i); + panoParserDumpImage(output); + } + printf("Input [%d] images ..................\n", script->iInputImagesCount); + + for (i=0;i<script->iInputImagesCount;i++) { + output = &script->inputImageSpec[i]; + printf(" image %d\n", i); + panoParserDumpImage(output); + } + +} + + + +int panoScriptParserReset(void) +{ + if (file != NULL) { return FALSE; + } /* There should not be anything allocated in script */ bzero(&script, sizeof(script)); + + //but some parameters are meaningful when zero + script.pano.projection = -1; return 1; } +int panoScriptParseProjectionParms() +{ + char *ptr; + float temp; + printf("Projecton parms [%s]\n", script.pano.projectionParmsString); -pt_script *panoParseScript(char *filename) + if (script.pano.projectionParmsString != NULL) { + // We got parameters which we need to parse + ptr = script.pano.projectionParmsString; + while (*ptr != '\0') { + if (*ptr == ' ' || *ptr == '\t') + ptr++; + else { + if (script.pano.projectionParmsCount >= PANO_PARSER_MAX_PROJECTION_PARMS) { + panoScriptParserError("Too many parameters for projection %s (limit is %d)", script.pano.projectionParmsString, PANO_PARSER_MAX_PROJECTION_PARMS); + return FALSE; + } + if (sscanf(ptr, "%f", &temp) != 1) { + panoScriptParserError("Illegal floating point number in projection parameters %s", script.pano.projectionParmsString); + return FALSE; + } + script.pano.projectionParms[script.pano.projectionParmsCount] = temp; + script.pano.projectionParmsCount++; + } + } + } + return TRUE; + +} + +int panoScriptDeReferenceImageVariables(pt_script_image *images, int imagesCount) { + // if the index != 0 and the indexed image is within bounds, and the indexed image is not a reference... + // then set the imageindex, and clear the reference +#define UNLINK_VARIABLE(i,a,r) (ref= images[i].r-1, \ + (ref >= 0 && \ + ref < imagesCount && \ + images[ref].r == 0 ? \ + (images[i].a = images[ref].a, \ + images[i].r = 0, \ + change=1)\ + :1\ + )) + +#define UNLINK_VARIABLE2(a,b,c) + + int change = 1; + int ref; + int i,j; + // dereferrence until we are done + while (change) { + change = 0; + for (i=0;i<imagesCount;i++) { + UNLINK_VARIABLE(i,fHorFOV,fHorFOVIndex); + UNLINK_VARIABLE(i,yaw,yawIndex); + UNLINK_VARIABLE(i,roll,rollIndex); + UNLINK_VARIABLE(i,pitch,pitchIndex); + for (j=0;j<PANO_PARSER_COEF_COUNT;j++) { + UNLINK_VARIABLE(i,coef[j],coefIndex[j]); + } + } + } +#undef UNLINK_VARIABLE + char *names[7] = {"a","b","c","d","e","g","t"}; + +#define VERIFY_VARIABLE(i,r,m) if (images[i].r!=0) {panoScriptParserError("Unable to resolve reference for variable %s in image %i\n", m, i);return FALSE;} + + // Verify that all links are resolved + for (i=0;i<imagesCount;i++) { + VERIFY_VARIABLE(i,fHorFOVIndex,"v"); + VERIFY_VARIABLE(i,yawIndex, "y"); + VERIFY_VARIABLE(i,rollIndex, "r"); + VERIFY_VARIABLE(i,pitchIndex, "p"); + for (j=0;j<PANO_PARSER_COEF_COUNT;j++) { + VERIFY_VARIABLE(i,coefIndex[j], names[j]); + } + } +#undef VERIFY_VARIABLE + + return TRUE; +} + +int panoScriptDeReferenceVariables(pt_script* script) +{ + // function that dereferences variables in scripts. + if (!panoScriptDeReferenceImageVariables(script->inputImageSpec, script->iInputImagesCount)) + return FALSE; + if (!panoScriptDeReferenceImageVariables(script->outputImageSpec, script->iOutputImagesCount)) + return FALSE; + return TRUE; +} + + +pt_script *panoScriptParse(char *filename, int deferenceVariables) +{ + // filaname: input file + + // deferenceVariables: should references to other variables be resolved? + pt_script *scriptVar; - if (!panoParseReset() ) { + file = NULL; + if (!panoScriptParserReset() ) { // This is really an assertion fprintf(stderr, "This parser is not reentrant"); exit(1); @@ -232,41 +374,64 @@ if ( file == NULL ) { return NULL; } - if ( getNextLine() == 0 ) { + if ( panoScriptScannerGetNextLine() == 0 ) { if (yyparse() ==0) { // duplicate data structure to return scriptVar = calloc(1, sizeof(*scriptVar)); if (scriptVar == NULL) { - panoPrintError("Not enough memory"); - return NULL; + panoScriptParserError("Not enough memory"); + goto error; } + + // AT THIS POINT WE HAVE FINISHED PARSING + + // This is the best time to verify input values + // and to parse some of the optional parameters + + if (!panoScriptParseProjectionParms() ) { + panoScriptParserError("Illegal parameters to projection"); + goto error; + } + + // Deference if required + if (deferenceVariables) { + printf("REquestion referencing of variables .......................\n"); + if (!panoScriptDeReferenceVariables(&script)) + goto error; + } // Just making sure.. + fclose(file); assert(sizeof(*scriptVar) == sizeof(*scriptVar)); memcpy(scriptVar, &script, sizeof(*scriptVar)); return scriptVar; + } else { - return FALSE; + goto error; } - } else { - panoPrintError("Input file is empty"); - return NULL; + panoScriptParserError("Input file is empty"); + goto error; } - close (file); + // It should never reach here + assert(0); + error: + if (file != NULL) + fclose(file); + return NULL; } -void panoParseDispose(pt_script **scriptVar) +void panoParserDispose(pt_script **scriptVar) { int i; // free all the data structures in it before freeing the variable itself -#define FREE(a) ((a) != NULL, free(a)) +#define FREE(a) if ((a) != NULL) free(a) pt_script *ptr = *scriptVar; // Free pt_script_pano first - FREE(ptr->pano.projectionParms); + FREE(ptr->pano.projectionParmsString); FREE(ptr->pano.outputFormat); @@ -286,3 +451,154 @@ *scriptVar = NULL; } +// ACCESSORS + +float panoScriptGetImageCoefA(pt_script_image *pImage) +{ + assert(pImage != NULL); + return pImage->coef[0]; +} + +float panoScriptGetImageCoefB(pt_script_image *pImage) +{ + assert(pImage != NULL); + return pImage->coef[1]; +} + +float panoScriptGetImageCoefC(pt_script_image *pImage) +{ + assert(pImage != NULL); + return pImage->coef[2]; +} + +float panoScriptGetImageCoefD(pt_script_image *pImage) +{ + assert(pImage != NULL); + return pImage->coef[3]; +} + +float panoScriptGetImageCoefE(pt_script_image *pImage) +{ + assert(pImage != NULL); + return pImage->coef[4]; +} + +float panoScriptGetImageSheerX(pt_script_image *pImage) +{ + assert(pImage != NULL); + return pImage->coef[5]; +} + +float panoScriptGetImageSheerY(pt_script_image *pImage) +{ + assert(pImage != NULL); + return pImage->coef[6]; +} + +int panoScriptGetImageCropType(pt_script_image *pImage) +{ + assert(pImage != NULL); + return pImage->cropType; +} + + +int panoScriptGetImageMorphToFit(pt_script_image *pImage) +{ + assert(pImage != NULL); + return pImage->morphToFit; +} + + +int panoScriptGetInputImagesCount(pt_script *script) +{ + assert(script != NULL); + return script->iInputImagesCount; +} + + +int panoScriptGetOutputImagesCount(pt_script *script) +{ + assert(script != NULL); + return script->iOutputImagesCount; +} + +pt_script_image *panoScriptGetInputImage(pt_script *script, int i) +{ + assert(script != NULL); + if (i > panoScriptGetInputImagesCount(script)) { + return NULL; + } + return &(script->inputImageSpec[i]); +} + +pt_script_image *panoScriptGetOutputImage(pt_script *script, int i) +{ + assert(script != NULL); + if (i > panoScriptGetOutputImagesCount(script)) { + printf("NONE********\n"); + return NULL; + } + return &(script->outputImageSpec[i]); +} + +int panoScriptGetPanoProjection(pt_script *script) +{ + return script->pano.projection; +} + +int panoScriptGetPanoWidth(pt_script *script) +{ + return script->pano.width; +} + +int panoScriptGetPanoHeight(pt_script *script) +{ + return script->pano.height; +} + +float panoScriptGetPanoHFOV(pt_script *script) +{ + return script->pano.fHorFOV; +} + +float panoScriptGetPanoParmsCount(pt_script *script) +{ + return script->pano.projectionParmsCount; +} + +float panoScriptGetPanoParm(pt_script *script, int index) +{ + assert(index < PANO_PARSER_MAX_PROJECTION_PARMS); + return script->pano.projectionParms[index]; +} + +char *panoScriptGetPanoOutputFormat(pt_script *script) +{ + return script->pano.outputFormat; +} + +int panoScriptGetImageProjection(pt_script_image *pImage) +{ + return pImage->projection; +} + + + + +float panoScriptGetImageHFOV(pt_script_image *pImage) +{ + return pImage->fHorFOV; +} + +float panoScriptGetImagePitch(pt_script_image *pImage) +{ + return pImage->pitch; +} +float panoScriptGetImageYaw(pt_script_image *pImage) +{ + return pImage->yaw; +} +float panoScriptGetImageRoll(pt_script_image *pImage) +{ + return pImage->roll; +} Modified: libpanorama/trunk/src/parser/tparser.h =================================================================== --- libpanorama/trunk/src/parser/tparser.h 2007-04-11 09:45:53 UTC (rev 72) +++ libpanorama/trunk/src/parser/tparser.h 2007-04-18 16:28:05 UTC (rev 73) @@ -24,24 +24,36 @@ * */ +#ifndef __TPARSER_H__ +#define __TPARSER_H__ + /* Maximum size for an input token */ #define PARSER_MAX_LINE 1000 #define PT_TOKEN_MAX_LEN PARSER_MAX_LINE +#define PANO_PARSER_MAX_PROJECTION_PARMS 10 /* Data structure where the entire input file will be read */ +#ifndef FALSE #define FALSE 0 -#define TRUE 0 +#endif +#ifndef TRUE +#define TRUE 1 +#endif +#define PANO_PARSER_COEF_COUNT 7 + typedef struct { int width; int height; int projection; - char *projectionParms; + int projectionParmsCount; + float projectionParms[PANO_PARSER_MAX_PROJECTION_PARMS]; + char *projectionParmsString; char *projectionName; float fHorFOV; char *outputFormat; @@ -57,16 +69,16 @@ float roll; float coef[7]; // a, b, c, d, e , g, t char *name; - int cropType ; - int cropArea[4]; - int morphToFit; + char cropType ; // it can be 'S' or 'C' + int cropArea[PANO_PARSER_COEF_COUNT]; // the rectangle to crop to + int morphToFit; // true if morph to fit // pointers to variable if they are used. // For the sake of simplicity they start at 1, if they are zero they are unused int fHorFOVIndex; int yawIndex; int pitchIndex; int rollIndex; - int coefIndex[7]; // a, b, c, d, e , g, t + int coefIndex[PANO_PARSER_COEF_COUNT]; // a, b, c, d, e , g, t } pt_script_image; typedef struct { @@ -91,12 +103,40 @@ pt_script_optimize optimize; } pt_script; -pt_script *Read_Script(char *fileName); +pt_script *panoScriptParse(char *filename, int deferenceVariables); +void panoScriptDispose(pt_script **scriptVar); +void panoScriptDump(pt_script *script); -void TokenBegin(char *t) ; -int GetNextChar(char *b, int maxBuffer) ; -void Parse_Error(char const *errorstring, ...) ; +// Accessors to the data structures above... +// they are the preferred way to access the data in them +float panoScriptGetImageCoefA(pt_script_image *pImage); +float panoScriptGetImageCoefB(pt_script_image *pImage); +float panoScriptGetImageCoefC(pt_script_image *pImage); +float panoScriptGetImageCoefD(pt_script_image *pImage); +float panoScriptGetImageCoefE(pt_script_image *pImage); +float panoScriptGetImageSheerX(pt_script_image *pImage); +float panoScriptGetImageSheerY(pt_script_image *pImage); +int panoScriptGetImageCropType(pt_script_image *pImage); +int panoScriptGetImageMorphToFit(pt_script_image *pImage); +int panoScriptGetInputImagesCount(pt_script *script); +int panoScriptGetOutputImagesCount(pt_script *script); +pt_script_image *panoScriptGetInputImage(pt_script *script, int i); +pt_script_image *panoScriptGetOutputImage(pt_script *script, int i); +int panoScriptGetPanoProjection(pt_script *script); +int panoScriptGetPanoWidth(pt_script *script); +int panoScriptGetPanoHeight(pt_script *script); +float panoScriptGetPanoHFOV(pt_script *script); +float panoScriptGetPanoParmsCount(pt_script *script); +float panoScriptGetPanoParm(pt_script *script, int index); +char *panoScriptGetPanoOutputFormat(pt_script *script); +int panoScriptGetImageProjection(pt_script_image *pImage); +float panoScriptGetImageHFOV(pt_script_image *pImage); +float panoScriptGetImagePitch(pt_script_image *pImage); +float panoScriptGetImageYaw(pt_script_image *pImage); +float panoScriptGetImageRoll(pt_script_image *pImage); +#endif + Added: libpanorama/trunk/src/parser/tparserprivate.h =================================================================== --- libpanorama/trunk/src/parser/tparserprivate.h (rev 0) +++ libpanorama/trunk/src/parser/tparserprivate.h 2007-04-18 16:28:05 UTC (rev 73) @@ -0,0 +1,38 @@ +/* + * tparserprivate.h + * + * Copyright Daniel M. German + * + * April 2007 + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this software; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Author: Daniel M German dmgerman at uvic doooot ca + * + */ + +// Defines that are not to be made public outside the parser + +#ifndef __TPARSER_PUBLIC_H__ +#define __TPARSER_PUBLIC_H__ + +void TokenBegin(char *t) ; +int panoScriptScannerGetNextChar(char *b, int maxBuffer) ; +void panoScriptParserError(char const *errorstring, ...) ; +void panoScriptScannerTokenBegin(char *t) ; + + +#endif This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dm...@us...> - 2007-06-06 16:05:47
|
Revision: 2064 http://hugin.svn.sourceforge.net/hugin/?rev=2064&view=rev Author: dmg Date: 2007-06-06 09:05:46 -0700 (Wed, 06 Jun 2007) Log Message: ----------- 2007-06-06 dmg <dm...@uv...> * Added support for reading control points. 2007-05-13 dmg <dm...@uv...> * scanner.l, parser.y: Changed PT_TOKEN_FLOAT to PT_TOKEN_NUMBER. Removed PT_TOKEN_INT. Now all numbers are float, but down-converted to int if necessary (using lroundf). Created a new token for cropping (PT_TOKEN_CROPPING). It simplifies error messages. 2007-05-03 dmg <dm...@uv...> * parser.y (PT_TOKEN_STRING): Fixed spelling mistake in huberEstimator * tparser.c (panoScriptParse): Fixed spelling mistake in name of parameter Modified Paths: -------------- libpanorama/trunk/src/parser/ChangeLog libpanorama/trunk/src/parser/parser.y libpanorama/trunk/src/parser/scanner.l libpanorama/trunk/src/parser/tparser.c libpanorama/trunk/src/parser/tparser.h libpanorama/trunk/src/parser/tparserprivate.h Modified: libpanorama/trunk/src/parser/ChangeLog =================================================================== --- libpanorama/trunk/src/parser/ChangeLog 2007-06-05 21:44:50 UTC (rev 2063) +++ libpanorama/trunk/src/parser/ChangeLog 2007-06-06 16:05:46 UTC (rev 2064) @@ -1,3 +1,20 @@ +2007-06-06 dmg <dm...@uv...> + + * Added support for reading control points. + +2007-05-13 dmg <dm...@uv...> + + * scanner.l, parser.y: Changed PT_TOKEN_FLOAT to + PT_TOKEN_NUMBER. Removed PT_TOKEN_INT. Now all numbers are float, + but down-converted to int if necessary (using lroundf). Created a + new token for cropping (PT_TOKEN_CROPPING). It simplifies error messages. + +2007-05-03 dmg <dm...@uv...> + + * parser.y (PT_TOKEN_STRING): Fixed spelling mistake in huberEstimator + + * tparser.c (panoScriptParse): Fixed spelling mistake in name of parameter + 2007-04-18 dmg <dm...@uv...> * tparser.c, tparser.h: Renamed some functions to the tlalli naming Modified: libpanorama/trunk/src/parser/parser.y =================================================================== --- libpanorama/trunk/src/parser/parser.y 2007-06-05 21:44:50 UTC (rev 2063) +++ libpanorama/trunk/src/parser/parser.y 2007-06-06 16:05:46 UTC (rev 2064) @@ -44,6 +44,8 @@ #define YYERROR_VERBOSE 1 static pt_script_image *image; +static pt_script_ctrl_point *ctrlPoint; +static pt_script_morph_point *morphPoint; /* copy a string while allocating and checking for memory */ @@ -53,7 +55,7 @@ free(*dest); *dest = strdup(from); if (*dest == NULL) - panoScriptParserError("Not enough memory"); + panoScriptParserError(1,"Not enough memory"); } @@ -71,19 +73,21 @@ %token NUM %token PT_TOKEN_SEP -%token <iVal> PT_TOKEN_INT -%token <fVal> PT_TOKEN_FLOAT +%token <fVal> PT_TOKEN_NUMBER %token <strVal> PT_TOKEN_STRING %token <cVal> PT_TOKEN_KEYWORD +%token <cVal> PT_TOKEN_CROPPING + %token PT_TOKEN_EOL %token PT_TOKEN_SEPARATOR %token PT_TOKEN_INPUT_LINE %token PT_TOKEN_OUTPUT_LINE %token PT_TOKEN_PANO_LINE %token PT_TOKEN_OPTIMIZE_LINE -%token PT_TOKEN_CONTROL_PTS_LINE +%token PT_TOKEN_CONTROL_PT_LINE %token PT_TOKEN_COMMA %token PT_TOKEN_REFERENCE +%token PT_TOKEN_MORPH_PT_LINE %start input @@ -91,8 +95,37 @@ %% /* Grammar rules and actions follow. */ input: lines - { return 0;} + { + int i; + pt_script_morph_point *morphPoint2; + int image; + pt_script_image *imageSpec; + // We have to move the morphing control points to their corresponding images + for (i = 0; i < script.iMorphPointsCount; i++) { + fprintf(stderr, "abc************************************\n"); + // get a pointer to the point to make life easier + morphPoint = &morphPointsSpec[i]; + image = morphPoint->iImage; + // we need to verify that the iamge pointer exists + if (image < 0 || image > script.iInputImagesCount) { + panoScriptParserError(0,"Morphing control point number %d references non existent input image [%c].\n", i, image); + return -1; + } + // point to the image, avoids long dereferrencing + imageSpec = &script.inputImageSpec[image]; + // allocate the pointer + morphPoint2 = (pt_script_morph_point *)panoScriptReAlloc((void*)&imageSpec->morphPoints, + sizeof(pt_script_morph_point), &imageSpec->morphPointsCount); + + memcpy(morphPoint2, morphPoint, sizeof(pt_script_morph_point)); + } + for (i=0;i<script.iInputImagesCount; i++) { + fprintf(stderr, "LLLLLLLLLLLLLLLLLLLLLLL %d\n", script.inputImageSpec[image].morphPointsCount); + } + return 0; + } + lines: | line input { @@ -104,14 +137,39 @@ | outputline | panoline | optimizeline - | PT_TOKEN_CONTROL_PTS_LINE PT_TOKEN_SEPARATOR vars eoln { ; } + | ctrlPtsLine + | morphPtsLine ; + +ctrlPtsLine: PT_TOKEN_CONTROL_PT_LINE PT_TOKEN_SEPARATOR + { + currentLine = PT_TOKEN_CONTROL_PT_LINE; + ctrlPoint = (pt_script_ctrl_point *)panoScriptReAlloc((void*)&script.ctrlPointsSpec, + sizeof(pt_script_ctrl_point), &script.iCtrlPointsCount); + } + varsparms eoln { ; } + +morphPtsLine: PT_TOKEN_MORPH_PT_LINE PT_TOKEN_SEPARATOR + { + currentLine = PT_TOKEN_MORPH_PT_LINE; + morphPoint = (pt_script_morph_point *)panoScriptReAlloc((void*)&morphPointsSpec, + sizeof(pt_script_morph_point), &script.iMorphPointsCount); + } + varsparms eoln { ; } + + eoln: PT_TOKEN_EOL { currentLine = -1; /* This says we don't know the type of line being processed */} inputline: PT_TOKEN_INPUT_LINE PT_TOKEN_SEPARATOR { + currentLine = PT_TOKEN_INPUT_LINE; + + image = (pt_script_image *)panoScriptReAlloc((void*)&(script.inputImageSpec), + sizeof(pt_script_image), &script.iInputImagesCount); + +#ifdef asdfasf // allocate the new output script.iInputImagesCount++; script.inputImageSpec = realloc(script.inputImageSpec, @@ -122,6 +180,7 @@ // clear the end of the reallocated region bzero(&(script.inputImageSpec[script.iInputImagesCount-1]), sizeof(*script.inputImageSpec)); image = &script.inputImageSpec[script.iInputImagesCount-1]; +#endif } vars eoln { ; } @@ -148,11 +207,17 @@ vars: var | vars PT_TOKEN_SEPARATOR var -var: varparameter | varseveralparms | varreference | varonly +/* a variable can be a cropping one (with 4 parms), a one-parm one, a reference to another variable, or finally, a name + only */ +var: varcropping | varparameter | varreference | varonly +varsparms: varparameter + | varsparms PT_TOKEN_SEPARATOR varparameter + + /* Rule for input image field references <var>=<index> */ -varreference: PT_TOKEN_KEYWORD PT_TOKEN_REFERENCE PT_TOKEN_FLOAT +varreference: PT_TOKEN_KEYWORD PT_TOKEN_REFERENCE PT_TOKEN_NUMBER { int imageRef = lroundf($3) + 1; switch (currentLine) { @@ -184,19 +249,19 @@ image->coefIndex[6] = imageRef; break; default: - panoScriptParserError("Invalid variable name [%c] in input line\n", $1); + panoScriptParserError(1,"Invalid variable name [%c] in input line.\n", $1); return -1; break; } break; default: - panoScriptParserError("Error Not handled 3 [%c]\n", $1); + panoScriptParserError(1,"Error Not handled 3 [%c]\n", $1); return -1; } } /* Rule for [CS]<x>,<x>,<x>,<x> */ -varseveralparms: PT_TOKEN_KEYWORD PT_TOKEN_INT PT_TOKEN_COMMA PT_TOKEN_INT PT_TOKEN_COMMA PT_TOKEN_INT PT_TOKEN_COMMA PT_TOKEN_INT +varcropping: PT_TOKEN_CROPPING PT_TOKEN_NUMBER PT_TOKEN_COMMA PT_TOKEN_NUMBER PT_TOKEN_COMMA PT_TOKEN_NUMBER PT_TOKEN_COMMA PT_TOKEN_NUMBER { switch (currentLine) { case PT_TOKEN_OUTPUT_LINE: @@ -211,20 +276,18 @@ image->cropArea[3] = lroundf($8); break; default: - panoScriptParserError("Invalid variable name [%c] in image line\n", $1); + panoScriptParserError(1,"Invalid variable name- [%c] in image line\n", $1); return -1; } break; default: - panoScriptParserError("Error Not handled 3\n"); + panoScriptParserError(1,"Error Not handled 3\n"); return -1; } } /* Rules for <variable><parameter> - I repeat the processing of some variables in int and float type because I don't really know - how to deal with both data types in a simple rule as I don't want to always upgrade ints to floats. */ varparameter: PT_TOKEN_KEYWORD PT_TOKEN_STRING { @@ -242,7 +305,7 @@ ParserStringCopy(&script.pano.projectionParmsString, $2); break; default: - panoScriptParserError("Invalid variable name [%c] in pano line\n", $1); + panoScriptParserError(1,"Invalid variable name [%c] in pano line\n", $1); return -1; } break; @@ -253,19 +316,71 @@ ParserStringCopy(&image->name, $2); break; default: - panoScriptParserError("Invalid variable name [%c] in image line\n", $1); + panoScriptParserError(1,"Invalid variable name [%c] in image line..\n", $1); return -1; } break; default: - panoScriptParserError("Error Not handled case [%c]\n", $1); + panoScriptParserError(1,"Error Not handled case [%c]\n", $1); return -1; } } - | PT_TOKEN_KEYWORD PT_TOKEN_FLOAT + | PT_TOKEN_KEYWORD PT_TOKEN_NUMBER { /* Processing of int variables */ switch (currentLine) { + case PT_TOKEN_CONTROL_PT_LINE: + switch ($1) { + case 'n': + ctrlPoint->iImage1 = lround($2); + break; + case 'N': + ctrlPoint->iImage2 = lround($2); + break; + case 'x': + ctrlPoint->p1.x = $2; + break; + case 'y': + ctrlPoint->p1.y = $2; + break; + case 'X': + ctrlPoint->p2.x = $2; + break; + case 'Y': + ctrlPoint->p2.y = $2; + break; + case 't': + ctrlPoint->type = $2; + break; + default: + panoScriptParserError(1, "Invalid variable name [%c] in input line.\n", $1); + return -1; + break; + } + break; + case PT_TOKEN_MORPH_PT_LINE: + switch ($1) { + case 'i': + morphPoint->iImage = lround($2); + break; + case 'x': + morphPoint->p1.x = $2; + break; + case 'y': + morphPoint->p1.y = $2; + break; + case 'X': + morphPoint->p2.x = $2; + break; + case 'Y': + morphPoint->p2.y = $2; + break; + default: + panoScriptParserError(1, "Invalid variable name [%c] in input line.\n", $1); + return -1; + break; + } + break; case PT_TOKEN_PANO_LINE: switch ($1) { case 'w': @@ -281,13 +396,13 @@ script.pano.fHorFOV = $2; break; case 'E': - panoScriptParserError("Invalid variable name [%c] in pano line. Ignored...\n", $1); + panoScriptParserError(1,"Invalid variable name [%c] in pano line. Ignored...\n", $1); break; case 'R': - panoScriptParserError("Invalid variable name [%c] in pano line. Ignored...\n", $1); + panoScriptParserError(1,"Invalid variable name [%c] in pano line. Ignored...\n", $1); break; default: - panoScriptParserError("Invalid variable name [%c] in pano line\n", $1); + panoScriptParserError(1,"Invalid variable name [%c] in pano line\n", $1); return -1; } break; @@ -330,10 +445,10 @@ break; case 'u': case 'm': - printf("Option %c in image line deprecated. \n", $1); + printf("Option %c in image line deprecated. Ignored...\n", $1); break; default: - panoScriptParserError("Invalid variable name [%c] in image line\n", $1); + panoScriptParserError(1,"Invalid variable name [%c] in image line...\n", $1); return -1; } break; @@ -349,18 +464,18 @@ script.optimize.fastFT = lroundf($2); break; case 'm': - script.optimize.humberEstimator = lround($2); + script.optimize.huberEstimator = lround($2); break; case 'p': - panoScriptParserError("Invalid variable name [%c] in optimize line. Ignored...\n", $1); + panoScriptParserError(1,"Obsolete variable name [%c] in optimize line. Ignored...\n", $1); break; default: - panoScriptParserError("Invalid variable name [%c] in optimize line\n", $1); + panoScriptParserError(1,"Invalid variable name [%c] in optimize line\n", $1); return -1; } break; default: - panoScriptParserError("Error. Not handled (token int [%c]\n", $1); + panoScriptParserError(1,"Error. Not handled (token int [%c]\n", $1); return -1; } } @@ -372,10 +487,10 @@ case PT_TOKEN_PANO_LINE: switch ($1) { case 'T': - panoScriptParserError("Invalid variable name [%c] in pano line. Ignored...\n", $1); + panoScriptParserError(1,"Invalid variable name [%c] in pano line. Ignored...\n", $1); break; default: - panoScriptParserError("Invalid variable name [%c] in pano line\n", $1); + panoScriptParserError(1,"Invalid variable name [%c] in pano line\n", $1); return -1; } break; @@ -383,12 +498,12 @@ case PT_TOKEN_INPUT_LINE: switch ($1) { default: - panoScriptParserError("Invalid variable name [%c] in image line\n", $1); + panoScriptParserError(1,"Invalid variable name [%c] in image line....\n", $1); return -1; } break; default: - panoScriptParserError("Error Not handled 3\n"); + panoScriptParserError(1,"Error Not handled 3\n"); return -1; } } Modified: libpanorama/trunk/src/parser/scanner.l =================================================================== --- libpanorama/trunk/src/parser/scanner.l 2007-06-05 21:44:50 UTC (rev 2063) +++ libpanorama/trunk/src/parser/scanner.l 2007-06-06 16:05:46 UTC (rev 2064) @@ -70,14 +70,14 @@ /* printf( "An integer: %s (%d)\n", yytext, atoi( yytext ) );*/ panoScriptScannerTokenBegin(yytext); yylval.fVal = atof( yytext ); - return PT_TOKEN_FLOAT; + return PT_TOKEN_NUMBER; } -?{DIGIT}+"."{DIGIT}* { /*printf( "A float: %s (%g)\n", yytext, atof( yytext ) );*/ panoScriptScannerTokenBegin(yytext); yylval.fVal = atof( yytext ); - return PT_TOKEN_FLOAT; + return PT_TOKEN_NUMBER; } ^[ \t]*\n { /* Ignore empty lines */ @@ -101,8 +101,6 @@ ^v.*\n { ; } /* Ignore v lines */ -^c.*\n { ; } /* Ignore c lines */ - /* Hugin specific variables. When they are supported it would be easier to generate a new type of token for them. For the time being just ignore them */ @@ -110,7 +108,6 @@ [EKVR][0-9A-Za-z.=-]+[ \t]* { panoScriptScannerTokenBegin(yytext); } /* ignore K, V,R and E parameters */ - /* These are the types of lines supported */ ^o { panoScriptScannerTokenBegin(yytext); @@ -132,11 +129,17 @@ return PT_TOKEN_OPTIMIZE_LINE; } +^c { + panoScriptScannerTokenBegin(yytext); + return PT_TOKEN_CONTROL_PT_LINE; + } + ^C { panoScriptScannerTokenBegin(yytext); - return PT_TOKEN_CONTROL_PTS_LINE; + return PT_TOKEN_MORPH_PT_LINE; } + /*********************************/ "," { @@ -144,6 +147,13 @@ return PT_TOKEN_COMMA; } +[CS] { + printf("Multi variable: %s\n", yytext); + strncpy(yylval.strVal, yytext, PT_TOKEN_MAX_LEN); + return PT_TOKEN_CROPPING; + } + + {ID} { /*printf( "An identifier: %s\n", yytext );*/ if (!inVariable) { @@ -205,7 +215,7 @@ <str>\n { /* error - unterminated string constant */ /* generate error message */ - panoScriptParserError( "non-terminated string: %s\n", yytext ); + panoScriptParserError(1,"non-terminated string: %s\n", yytext ); return -0; } @@ -225,7 +235,7 @@ } . { - panoScriptParserError( "Unrecognized character: %s\n", yytext ); + panoScriptParserError(1,"Unrecognized character: %s\n", yytext ); return 0; } Modified: libpanorama/trunk/src/parser/tparser.c =================================================================== --- libpanorama/trunk/src/parser/tparser.c 2007-06-05 21:44:50 UTC (rev 2063) +++ libpanorama/trunk/src/parser/tparser.c 2007-06-06 16:05:46 UTC (rev 2064) @@ -357,7 +357,7 @@ } -pt_script *panoScriptParse(char *filename, int deferenceVariables) +pt_script *panoScriptParse(char *filename, int dereferenceVariables) { // filaname: input file @@ -394,7 +394,7 @@ } // Deference if required - if (deferenceVariables) { + if (dereferenceVariables) { printf("REquestion referencing of variables .......................\n"); if (!panoScriptDeReferenceVariables(&script)) goto error; Modified: libpanorama/trunk/src/parser/tparser.h =================================================================== --- libpanorama/trunk/src/parser/tparser.h 2007-06-05 21:44:50 UTC (rev 2063) +++ libpanorama/trunk/src/parser/tparser.h 2007-06-06 16:05:46 UTC (rev 2064) @@ -48,6 +48,25 @@ #define PANO_PARSER_COEF_COUNT 7 typedef struct { + double x; + double y; +} pt_point; + +typedef struct { + int iImage; + pt_point p1; + pt_point p2; +} pt_script_morph_point; + +typedef struct { + int iImage1; + int iImage2; + pt_point p1; + pt_point p2; + int type; +} pt_script_ctrl_point; + +typedef struct { int width; int height; int projection; @@ -67,7 +86,7 @@ float yaw; float pitch; float roll; - float coef[7]; // a, b, c, d, e , g, t + float coef[7]; // a, b, c, d, e, g, t char *name; char cropType ; // it can be 'S' or 'C' int cropArea[PANO_PARSER_COEF_COUNT]; // the rectangle to crop to @@ -79,18 +98,16 @@ int pitchIndex; int rollIndex; int coefIndex[PANO_PARSER_COEF_COUNT]; // a, b, c, d, e , g, t + int morphPointsCount; + pt_script_morph_point *morphPoints; } pt_script_image; -typedef struct { - int iImage; - float x1, y1, x2, y2; -} pt_script_morphing_points; typedef struct { float fGamma; int interpolator; int fastFT; - int humberEstimator; + int huberEstimator; } pt_script_optimize; typedef struct { @@ -99,15 +116,20 @@ pt_script_image *inputImageSpec; int iOutputImagesCount; pt_script_image *outputImageSpec; - pt_script_morphing_points *morphingPointsSpec; + int iMorphPointsCount; pt_script_optimize optimize; + int iCtrlPointsCount; + pt_script_ctrl_point *ctrlPointsSpec; } pt_script; +static pt_script_morph_point *morphPointsSpec = NULL; + pt_script *panoScriptParse(char *filename, int deferenceVariables); void panoScriptDispose(pt_script **scriptVar); void panoScriptDump(pt_script *script); + // Accessors to the data structures above... // they are the preferred way to access the data in them @@ -138,5 +160,8 @@ float panoScriptGetImageRoll(pt_script_image *pImage); + + + #endif Modified: libpanorama/trunk/src/parser/tparserprivate.h =================================================================== --- libpanorama/trunk/src/parser/tparserprivate.h 2007-06-05 21:44:50 UTC (rev 2063) +++ libpanorama/trunk/src/parser/tparserprivate.h 2007-06-06 16:05:46 UTC (rev 2064) @@ -31,8 +31,9 @@ void TokenBegin(char *t) ; int panoScriptScannerGetNextChar(char *b, int maxBuffer) ; -void panoScriptParserError(char const *errorstring, ...) ; void panoScriptScannerTokenBegin(char *t) ; +void panoScriptParserError(int showLine, char const *errorstring, ...) ; +void *panoScriptReAlloc(char **ptr, int size, int *count); #endif This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dm...@us...> - 2007-06-07 03:13:11
|
Revision: 2066 http://hugin.svn.sourceforge.net/hugin/?rev=2066&view=rev Author: dmg Date: 2007-06-06 20:13:09 -0700 (Wed, 06 Jun 2007) Log Message: ----------- I failed to udpate tparser.c Modified Paths: -------------- libpanorama/trunk/src/parser/Makefile.am libpanorama/trunk/src/parser/tparser.c Modified: libpanorama/trunk/src/parser/Makefile.am =================================================================== --- libpanorama/trunk/src/parser/Makefile.am 2007-06-07 03:06:05 UTC (rev 2065) +++ libpanorama/trunk/src/parser/Makefile.am 2007-06-07 03:13:09 UTC (rev 2066) @@ -1,7 +1,12 @@ DEFAULT_INCLUDES="-I." -BUILT_SOURCES = parser.h +TLALILIB=tlalli +AM_CPPFLAGS = $(JAVA_FLAGS) $(LIN_DEFS) $(DAR_DEFS) $(TIFF_FLAGS) $(JPEG_FLAGS) +AM_LDFLAGS = -L${top_builddir} + +BUILT_SOURCES = parser.h parser.c scanner.c + AM_YFLAGS = -d AM_LFLAGS = -o$(LEX_OUTPUT_ROOT).c @@ -12,7 +17,7 @@ bin_PROGRAMS = Tparser -Tparser_SOURCES = Tparser.c parser.y scanner.l parser.h tparser.h +Tparser_SOURCES = Tparser.c parser.y scanner.l parser.h tparser.h testparser.c Tparser_LDADD = -l${TLALILIB} -lfl -lm MAINTAINERCLEANFILES = \ Modified: libpanorama/trunk/src/parser/tparser.c =================================================================== --- libpanorama/trunk/src/parser/tparser.c 2007-06-07 03:06:05 UTC (rev 2065) +++ libpanorama/trunk/src/parser/tparser.c 2007-06-07 03:13:09 UTC (rev 2066) @@ -66,7 +66,10 @@ fprintf(stdout, "%6d |%.*s", nRow, lBuffer, buffer); } -void panoScriptParserError(char const *errorstring, ...) + +/* Display parsing error, including the current line and a pointer to the error token */ + +void panoScriptParserError(int showLine, char const *errorstring, ...) { static char errmsg[1000]; va_list args; @@ -104,25 +107,25 @@ int panoScriptScannerGetNextLine(void) { - char *p; - - nBuffer = 0; - nTokenStart = -1; - nTokenNextStart = 1; - eof = FALSE; - - p = fgets(buffer, lMaxBuffer, file); - if ( p == NULL ) { - if ( ferror(file) ) - return -1; - eof = TRUE; - return 1; - } - - nRow += 1; - lBuffer = strlen(buffer); - - return 0; + char *p; + + nBuffer = 0; + nTokenStart = -1; + nTokenNextStart = 1; + eof = FALSE; + + p = fgets(buffer, lMaxBuffer, file); + if ( p == NULL ) { + if ( ferror(file) ) + return -1; + eof = TRUE; + return 1; + } + + nRow += 1; + lBuffer = strlen(buffer); + + return 0; } // THis is the function that lex will use to read the next character @@ -150,6 +153,7 @@ return b[0]==0?0:1; } + void panoScriptScannerTokenBegin(char *t) { // REcord where a token begins @@ -161,11 +165,101 @@ void yyerror (char const *st) { - panoScriptParserError(st); + panoScriptParserError(1, st); } +// Reallocs ptr by size, count is the variable with the current number of records allocated +// actual data is in 1000 +// array located at 20 contains 1000 +// ptr has value 20 +// *ptr is 1000 + +void *panoScriptReAlloc(char **ptr, int size, int *count) +{ + char *temp; + + (*count)++; + *ptr = realloc(*ptr, *count * size); + if (ptr == NULL) { + yyerror("Not enough memory"); + return NULL; + } + // point to the newly allocated record + temp = (char*)*ptr; + temp+= size * ((*count)-1); + // clear the area + bzero(temp, size); + return temp; +} + +#ifdef delete +void *panoScriptReAllocI(pt_script_image **ptr, int size, int *count) +{ + char *temp = NULL; + + printf("Before ptr %x *ptr %x\n", ptr, *ptr); + printf("return temp %x *size %d, count %d\n", temp, size, *count); + + (*count)++; + + *ptr = realloc(*ptr, (*count) * size); + if (ptr == NULL) { + yyerror("Not enough memory"); + return NULL; + } + // point to the newly allocated record + temp = (char*)*ptr; + + printf("To resize count %d, %d\n", *count, (size * ((*count)-1))); + temp += size * ((*count)-1); + // clear the area + bzero(temp, size); + + printf("After ptr %x *ptr %x\n", ptr, *ptr); + printf("return temp %x *size %d, count %d\n", temp, size, *count); + return temp; +} +#endif + +/* + * dump a control point + */ +void panoParserDumpCtrlPoint(pt_script_ctrl_point *ctrlPoint) +{ + printf(" image1 %-5d (%6.1f,%6.1f) image2 %-5d (%6.1f,%6.1f) type %d\n", + ctrlPoint->iImage1, + ctrlPoint->p1.x, + ctrlPoint->p1.y, + ctrlPoint->iImage2, + ctrlPoint->p2.x, + ctrlPoint->p2.y, + ctrlPoint->type + ); +} + +/* + * dump a control point + */ +void panoParserDumpMorphPoint(pt_script_morph_point *ctrlPoint) +{ + printf(" image %-5d (%6.1f,%6.1f) to (%6.1f,%6.1f)\n", + ctrlPoint->iImage, + ctrlPoint->p1.x, + ctrlPoint->p1.y, + ctrlPoint->p2.x, + ctrlPoint->p2.y + ); +} + + +/* + Dump all information we know about a particular image +*/ void panoParserDumpImage(pt_script_image *output) { + int i; + pt_script_morph_point *morphPoint; + printf(" projection %d\n", output->projection); printf(" width, height %dx%d ", output->width, output->height); printf(" fHorFOV %f\n", output->fHorFOV); @@ -204,12 +298,26 @@ printf(" g %d", output->coefIndex[5]); printf(" t %d\n", output->coefIndex[6]); + printf(" Morphing points count %d\n", output->morphPointsCount); + + for (i=0;i<output->morphPointsCount;i++) { + printf(" %-5d ", i); + morphPoint = &output->morphPoints[i]; + panoParserDumpMorphPoint(morphPoint); + } + } +/* + Dump all the script information we have read +*/ + void panoScriptDump(pt_script *script) { int i; pt_script_image *output; + pt_script_ctrl_point *ctrlPoint; + pt_script_morph_point *morphPoint; assert(script != NULL); @@ -230,7 +338,7 @@ printf(" gamma %f", script->optimize.fGamma); printf(" interpolator %d", script->optimize.interpolator); printf(" fastFT %d ", script->optimize.fastFT); - printf(" humber %d \n", script->optimize.humberEstimator); + printf(" huber estimator %d \n", script->optimize.huberEstimator); printf("Output [%d] images ..................\n", script->iOutputImagesCount); @@ -246,11 +354,28 @@ printf(" image %d\n", i); panoParserDumpImage(output); } - + printf("Ctrl points [%d] ..................\n", script->iCtrlPointsCount); + for (i=0;i<script->iCtrlPointsCount;i++) { + ctrlPoint = &script->ctrlPointsSpec[i]; + printf(" %-5d ", i); + panoParserDumpCtrlPoint(ctrlPoint); + // panoParserDumpImage(output); + } +#ifdef adfasdf + printf("Morphing points [%d] ..................\n", script->iMorphPointsCount); + for (i=0;i<script->iMorphPointsCount;i++) { + morphPoint = &morphPointsSpec[i]; + printf(" %-5d ", i); + panoParserDumpMorphPoint(morphPoint); + } +#endif } - +/* + This function is be called before the parser is used for the first time, and if it wants to be reused. + Remember, the parser is not REENTRANT + */ int panoScriptParserReset(void) { if (file != NULL) { @@ -264,6 +389,11 @@ return 1; } +/* + * Projection parms are outside the scope of the parser. In a way this is good, because they allow the use of + * _any_ type of parameters. On the other hand, it is bad because they have to be parsed here instead of the + * bison parser. + */ int panoScriptParseProjectionParms() { char *ptr; @@ -278,11 +408,11 @@ ptr++; else { if (script.pano.projectionParmsCount >= PANO_PARSER_MAX_PROJECTION_PARMS) { - panoScriptParserError("Too many parameters for projection %s (limit is %d)", script.pano.projectionParmsString, PANO_PARSER_MAX_PROJECTION_PARMS); + panoScriptParserError(1, "Too many parameters for projection %s (limit is %d)", script.pano.projectionParmsString, PANO_PARSER_MAX_PROJECTION_PARMS); return FALSE; } if (sscanf(ptr, "%f", &temp) != 1) { - panoScriptParserError("Illegal floating point number in projection parameters %s", script.pano.projectionParmsString); + panoScriptParserError(1, "Illegal floating point number in projection parameters %s", script.pano.projectionParmsString); return FALSE; } script.pano.projectionParms[script.pano.projectionParmsCount] = temp; @@ -294,6 +424,10 @@ } +/* + * In some cases variables can point to other variables for their actual parameters. This + * function derefereces them. + */ int panoScriptDeReferenceImageVariables(pt_script_image *images, int imagesCount) { // if the index != 0 and the indexed image is within bounds, and the indexed image is not a reference... @@ -310,6 +444,7 @@ #define UNLINK_VARIABLE2(a,b,c) + // First unlink the variables that we can int change = 1; int ref; int i,j; @@ -329,7 +464,7 @@ #undef UNLINK_VARIABLE char *names[7] = {"a","b","c","d","e","g","t"}; -#define VERIFY_VARIABLE(i,r,m) if (images[i].r!=0) {panoScriptParserError("Unable to resolve reference for variable %s in image %i\n", m, i);return FALSE;} +#define VERIFY_VARIABLE(i,r,m) if (images[i].r!=0) {panoScriptParserError(0, "Unable to resolve reference for variable %s in image %i\n", m, i);return FALSE;} // Verify that all links are resolved for (i=0;i<imagesCount;i++) { @@ -379,7 +514,7 @@ // duplicate data structure to return scriptVar = calloc(1, sizeof(*scriptVar)); if (scriptVar == NULL) { - panoScriptParserError("Not enough memory"); + panoScriptParserError(0, "Not enough memory"); goto error; } @@ -389,7 +524,7 @@ // and to parse some of the optional parameters if (!panoScriptParseProjectionParms() ) { - panoScriptParserError("Illegal parameters to projection"); + panoScriptParserError(1, "Illegal parameters to projection"); goto error; } @@ -401,6 +536,7 @@ } // Just making sure.. fclose(file); + file = NULL; assert(sizeof(*scriptVar) == sizeof(*scriptVar)); memcpy(scriptVar, &script, sizeof(*scriptVar)); return scriptVar; @@ -410,7 +546,7 @@ } } else { - panoScriptParserError("Input file is empty"); + panoScriptParserError(0, "Input file is empty"); goto error; } // It should never reach here @@ -440,10 +576,12 @@ } for (i=0;i<ptr->iInputImagesCount;i++) { FREE(ptr->inputImageSpec[i].name); + FREE(ptr->inputImageSpec[i].morphPoints); } FREE(ptr->outputImageSpec); FREE(ptr->inputImageSpec); - FREE(ptr->morphingPointsSpec); + FREE(morphPointsSpec); + FREE(ptr->ctrlPointsSpec); #undef FREE This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dm...@us...> - 2007-06-07 03:36:22
|
Revision: 2067 http://hugin.svn.sourceforge.net/hugin/?rev=2067&view=rev Author: dmg Date: 2007-06-06 20:36:20 -0700 (Wed, 06 Jun 2007) Log Message: ----------- Fixed cmake script. It does not create a library, but it creates the test executable Modified Paths: -------------- libpanorama/trunk/src/parser/CMakeLists.txt libpanorama/trunk/src/parser/ChangeLog Modified: libpanorama/trunk/src/parser/CMakeLists.txt =================================================================== --- libpanorama/trunk/src/parser/CMakeLists.txt 2007-06-07 03:13:09 UTC (rev 2066) +++ libpanorama/trunk/src/parser/CMakeLists.txt 2007-06-07 03:36:20 UTC (rev 2067) @@ -1,11 +1,8 @@ -#this is just a basic CMakeLists.txt, for more information see the cmake manpage +# these two variables were not defined for me -# parser stuff -#BISON_TARGET(mparser parser.y ${PROJECT_BINARY_DIR}/parser.cpp) -#FLEX_TARGET(mscanner scanner.l ${PROJECT_BINARY_DIR}/scanner.cpp) -#ADD_FLEX_BISON_DEPENDENCY(scanner parser) +SET(FLEX_EXECUTABLE flex) +SET(BISON_EXECUTABLE bison) - ADD_CUSTOM_COMMAND(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/parser.c ${CMAKE_CURRENT_BINARY_DIR}/parser.h COMMAND ${BISON_EXECUTABLE} -d -oparser.c ${CMAKE_CURRENT_SOURCE_DIR}/parser.y DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/parser.y ) @@ -18,14 +15,18 @@ include_directories( ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR} ) #build a shared library -ADD_LIBRARY(panoparser SHARED tparser.c - ${CMAKE_CURRENT_BINARY_DIR}/parser.c - ${CMAKE_CURRENT_BINARY_DIR}/scanner.c ) +#ADD_LIBRARY(panoparser SHARED tparser.c +# ${CMAKE_CURRENT_BINARY_DIR}/parser.c +# ${CMAKE_CURRENT_BINARY_DIR}/scanner.c ) #for testing the shared library you probably need some test app too -ADD_EXECUTABLE(testparser testparser.c) +ADD_EXECUTABLE(testparser testparser.c tparser.c + ${CMAKE_CURRENT_BINARY_DIR}/parser.c + ${CMAKE_CURRENT_BINARY_DIR}/scanner.c + ) + #link to the library -TARGET_LINK_LIBRARIES(testparser m panoparser) +#TARGET_LINK_LIBRARIES(testparser panoparser) #add an install target here #INSTALL_FILES(...) Modified: libpanorama/trunk/src/parser/ChangeLog =================================================================== --- libpanorama/trunk/src/parser/ChangeLog 2007-06-07 03:13:09 UTC (rev 2066) +++ libpanorama/trunk/src/parser/ChangeLog 2007-06-07 03:36:20 UTC (rev 2067) @@ -1,5 +1,7 @@ 2007-06-06 dmg <dm...@uv...> + * CMakeLists.txt: Fixed script. At least it now creates the test executable + * Tparser.c (panoParserDumpImage): Fixed a compilation error that slip through in my last commit This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dm...@us...> - 2007-06-14 23:54:24
|
Revision: 2092 http://hugin.svn.sourceforge.net/hugin/?rev=2092&view=rev Author: dmg Date: 2007-06-14 16:54:17 -0700 (Thu, 14 Jun 2007) Log Message: ----------- 2007-06-14 dmg <dm...@uv...> * parser.y: Fixed an out-of-bounds error. * tparserdebug.h, parser.y, tparser.c: added this file. Modified Paths: -------------- libpanorama/trunk/src/parser/ChangeLog libpanorama/trunk/src/parser/parser.y libpanorama/trunk/src/parser/tparser.c Added Paths: ----------- libpanorama/trunk/src/parser/tparserdebug.h Modified: libpanorama/trunk/src/parser/ChangeLog =================================================================== --- libpanorama/trunk/src/parser/ChangeLog 2007-06-14 14:10:57 UTC (rev 2091) +++ libpanorama/trunk/src/parser/ChangeLog 2007-06-14 23:54:17 UTC (rev 2092) @@ -1,3 +1,9 @@ +2007-06-14 dmg <dm...@uv...> + + * parser.y: Fixed an out-of-bounds error. + + * tparserdebug.h, parser.y, tparser.c: added this file. + 2007-06-09 Pablo d'Angelo <pab...@we...> * CMakeLists.txt: build a library for the parser anyway, this is Modified: libpanorama/trunk/src/parser/parser.y =================================================================== --- libpanorama/trunk/src/parser/parser.y 2007-06-14 14:10:57 UTC (rev 2091) +++ libpanorama/trunk/src/parser/parser.y 2007-06-14 23:54:17 UTC (rev 2092) @@ -32,6 +32,7 @@ #include "tparser.h" #include "tparserprivate.h" +#include "tparserdebug.h" int yylex (void); void yyerror (char const *); @@ -48,6 +49,7 @@ static pt_script_morph_point *morphPoint; + /* copy a string while allocating and checking for memory */ static void ParserStringCopy(char **dest, char *from) { @@ -97,10 +99,14 @@ input: lines { int i; + DEBUG_1("Lines"); + pt_script_morph_point *morphPoint2; int image; pt_script_image *imageSpec; // We have to move the morphing control points to their corresponding images + DEBUG_2("Number of control points %d", script.iMorphPointsCount); + for (i = 0; i < script.iMorphPointsCount; i++) { fprintf(stderr, "abc************************************\n"); // get a pointer to the point to make life easier @@ -120,9 +126,13 @@ memcpy(morphPoint2, morphPoint, sizeof(pt_script_morph_point)); } + DEBUG_2("Lines: number of images %d", script.iInputImagesCount); + for (i=0;i<script.iInputImagesCount; i++) { - fprintf(stderr, "LLLLLLLLLLLLLLLLLLLLLLL %d\n", script.inputImageSpec[image].morphPointsCount); + DEBUG_2("Image %d", script.inputImageSpec[i].morphPointsCount); } + DEBUG_2("Number of control points %d", script.iMorphPointsCount); + return 0; } @@ -132,7 +142,7 @@ printf("Per line...\n"); } -line: eoln { ; } +line: eoln { } | inputline | outputline | panoline @@ -186,6 +196,7 @@ outputline: PT_TOKEN_OUTPUT_LINE PT_TOKEN_SEPARATOR { + DEBUG_1("Reading outputline"); currentLine = PT_TOKEN_OUTPUT_LINE; // allocate the new output script.iOutputImagesCount++; @@ -220,6 +231,9 @@ varreference: PT_TOKEN_KEYWORD PT_TOKEN_REFERENCE PT_TOKEN_NUMBER { int imageRef = lroundf($3) + 1; + + DEBUG_1("Reading varreference"); + switch (currentLine) { case PT_TOKEN_INPUT_LINE: switch ($1) { @@ -291,6 +305,10 @@ */ varparameter: PT_TOKEN_KEYWORD PT_TOKEN_STRING { + yydebug = 0; + + DEBUG_2("Token %s", $2); + /* Processing of string variables */ switch (currentLine) { case PT_TOKEN_PANO_LINE: Modified: libpanorama/trunk/src/parser/tparser.c =================================================================== --- libpanorama/trunk/src/parser/tparser.c 2007-06-14 14:10:57 UTC (rev 2091) +++ libpanorama/trunk/src/parser/tparser.c 2007-06-14 23:54:17 UTC (rev 2092) @@ -33,6 +33,7 @@ #include "tparser.h" #include "parser.h" +#include "tparserdebug.h" int yyparse(void) ; @@ -77,6 +78,8 @@ int start=nTokenStart; int end=start + nTokenLength - 1; int i; + + DEBUG_1("Enterting panoscriptparserror\n"); panoScriptParserDumpRow(); @@ -499,6 +502,9 @@ // deferenceVariables: should references to other variables be resolved? pt_script *scriptVar; + + DEBUG_1("Starting to parse"); + file = NULL; if (!panoScriptParserReset() ) { // This is really an assertion Added: libpanorama/trunk/src/parser/tparserdebug.h =================================================================== --- libpanorama/trunk/src/parser/tparserdebug.h (rev 0) +++ libpanorama/trunk/src/parser/tparserdebug.h 2007-06-14 23:54:17 UTC (rev 2092) @@ -0,0 +1,38 @@ +/* + * tparserdebug.h + * + * Copyright Daniel M. German + * + * April 2007 + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public + * License along with this software; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * Author: Daniel M German dmgerman at uvic doooot ca + * + */ +#ifndef __TPARSERDEBUG_H__ + +#define __TPARSERDEBUG_H__ + +#ifdef YYDEBUG +#define DEBUG_1(a) fprintf(stderr, #a "\n", a); +#define DEBUG_2(a,b) fprintf(stderr, #a "\n", b); +#else +#define DEBUG_1(a) +#define DEBUG_2(a) +#endif + +#endif This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dm...@us...> - 2007-06-15 06:12:00
|
Revision: 2093 http://hugin.svn.sourceforge.net/hugin/?rev=2093&view=rev Author: dmg Date: 2007-06-14 23:11:54 -0700 (Thu, 14 Jun 2007) Log Message: ----------- 2007-06-14 dmg <dm...@uv...> * tparserdebug.h (DEBUG_2): THe #else had the wrong number of parms. Modified Paths: -------------- libpanorama/trunk/src/parser/ChangeLog libpanorama/trunk/src/parser/tparserdebug.h Modified: libpanorama/trunk/src/parser/ChangeLog =================================================================== --- libpanorama/trunk/src/parser/ChangeLog 2007-06-14 23:54:17 UTC (rev 2092) +++ libpanorama/trunk/src/parser/ChangeLog 2007-06-15 06:11:54 UTC (rev 2093) @@ -1,5 +1,7 @@ 2007-06-14 dmg <dm...@uv...> + * tparserdebug.h (DEBUG_2): THe #else had the wrong number of parms. + * parser.y: Fixed an out-of-bounds error. * tparserdebug.h, parser.y, tparser.c: added this file. Modified: libpanorama/trunk/src/parser/tparserdebug.h =================================================================== --- libpanorama/trunk/src/parser/tparserdebug.h 2007-06-14 23:54:17 UTC (rev 2092) +++ libpanorama/trunk/src/parser/tparserdebug.h 2007-06-15 06:11:54 UTC (rev 2093) @@ -32,7 +32,7 @@ #define DEBUG_2(a,b) fprintf(stderr, #a "\n", b); #else #define DEBUG_1(a) -#define DEBUG_2(a) +#define DEBUG_2(a,b) #endif #endif This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dm...@us...> - 2007-06-15 06:15:28
|
Revision: 2094 http://hugin.svn.sourceforge.net/hugin/?rev=2094&view=rev Author: dmg Date: 2007-06-14 23:15:27 -0700 (Thu, 14 Jun 2007) Log Message: ----------- 2007-06-14 dmg <dm...@uv...> * tparserdebug.h (DEBUG_2): THe #else had the wrong number of parms. Modified Paths: -------------- libpanorama/trunk/src/parser/ChangeLog libpanorama/trunk/src/parser/parser.y Modified: libpanorama/trunk/src/parser/ChangeLog =================================================================== --- libpanorama/trunk/src/parser/ChangeLog 2007-06-15 06:11:54 UTC (rev 2093) +++ libpanorama/trunk/src/parser/ChangeLog 2007-06-15 06:15:27 UTC (rev 2094) @@ -1,5 +1,7 @@ 2007-06-14 dmg <dm...@uv...> + * parser.y (PT_TOKEN_STRING): Removed yydebug for the time being. + * tparserdebug.h (DEBUG_2): THe #else had the wrong number of parms. * parser.y: Fixed an out-of-bounds error. Modified: libpanorama/trunk/src/parser/parser.y =================================================================== --- libpanorama/trunk/src/parser/parser.y 2007-06-15 06:11:54 UTC (rev 2093) +++ libpanorama/trunk/src/parser/parser.y 2007-06-15 06:15:27 UTC (rev 2094) @@ -305,7 +305,6 @@ */ varparameter: PT_TOKEN_KEYWORD PT_TOKEN_STRING { - yydebug = 0; DEBUG_2("Token %s", $2); This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dm...@us...> - 2007-06-28 02:47:41
|
Revision: 2176 http://hugin.svn.sourceforge.net/hugin/?rev=2176&view=rev Author: dmg Date: 2007-06-27 19:47:40 -0700 (Wed, 27 Jun 2007) Log Message: ----------- removed debugging messages Modified Paths: -------------- libpanorama/trunk/src/parser/ChangeLog libpanorama/trunk/src/parser/scanner.l libpanorama/trunk/src/parser/testparser.c libpanorama/trunk/src/parser/tparser.c Modified: libpanorama/trunk/src/parser/ChangeLog =================================================================== --- libpanorama/trunk/src/parser/ChangeLog 2007-06-28 00:17:18 UTC (rev 2175) +++ libpanorama/trunk/src/parser/ChangeLog 2007-06-28 02:47:40 UTC (rev 2176) @@ -1,5 +1,7 @@ 2007-06-27 dmg <dm...@uv...> + * Removed several debugging messages to make the output cleaner. + * parser.y: Improved error handling in case of unrecognized lines. Previously it was stopping at the first line it did not recognized, but returned no error. Modified: libpanorama/trunk/src/parser/scanner.l =================================================================== --- libpanorama/trunk/src/parser/scanner.l 2007-06-28 00:17:18 UTC (rev 2175) +++ libpanorama/trunk/src/parser/scanner.l 2007-06-28 02:47:40 UTC (rev 2176) @@ -196,12 +196,11 @@ [CS] { - printf("Multi variable: %s\n", yytext); + /*printf("Multi variable: %s\n", yytext); */ strncpy(yylval.strVal, yytext, PT_TOKEN_MAX_LEN); return PT_TOKEN_CROPPING; } - {ID} { /*printf( "An identifier: %s\n", yytext );*/ if (!inVariable) { Modified: libpanorama/trunk/src/parser/testparser.c =================================================================== --- libpanorama/trunk/src/parser/testparser.c 2007-06-28 00:17:18 UTC (rev 2175) +++ libpanorama/trunk/src/parser/testparser.c 2007-06-28 02:47:40 UTC (rev 2176) @@ -42,21 +42,26 @@ printf("Testing parser for panotools and hugin files\n"); + script = panoScriptParse(argv[1], FALSE); - script = panoScriptParse(argv[1], FALSE); + printf("\n\n-----------------Finished parsing\n"); + if (script == NULL) { printf("Parsing error\n"); } else { panoScriptDump(script); + printf("-------------------------------------------------\n"); + if (!panoScriptDeReferenceVariables(script)) { printf("Unable to de-reference all variable\n"); } + /* printf("Printing after variables are dereferrenced\n"); panoScriptDump(script); - + */ panoParserDispose(&script); } Modified: libpanorama/trunk/src/parser/tparser.c =================================================================== --- libpanorama/trunk/src/parser/tparser.c 2007-06-28 00:17:18 UTC (rev 2175) +++ libpanorama/trunk/src/parser/tparser.c 2007-06-28 02:47:40 UTC (rev 2176) @@ -404,7 +404,6 @@ { char *ptr; float temp; - printf("Projecton parms [%s]\n", script.pano.projectionParmsString); if (script.pano.projectionParmsString != NULL) { // We got parameters which we need to parse This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dm...@us...> - 2007-06-28 22:16:47
|
Revision: 2191 http://hugin.svn.sourceforge.net/hugin/?rev=2191&view=rev Author: dmg Date: 2007-06-28 15:16:45 -0700 (Thu, 28 Jun 2007) Log Message: ----------- 007-06-28 dmg <dm...@uv...> * parser.y, tparser.c, tparser.h: Implemented R variable in p-line * parser.y, tparser.c, tparser.h, scanner.l: Implemented Hugin autoCenterCrop and cropFactor in i-lines. Modified Paths: -------------- libpanorama/trunk/src/parser/ChangeLog libpanorama/trunk/src/parser/TODO libpanorama/trunk/src/parser/parser.y libpanorama/trunk/src/parser/scanner.l libpanorama/trunk/src/parser/testparser.c libpanorama/trunk/src/parser/tparser.c libpanorama/trunk/src/parser/tparser.h Modified: libpanorama/trunk/src/parser/ChangeLog =================================================================== --- libpanorama/trunk/src/parser/ChangeLog 2007-06-28 21:44:08 UTC (rev 2190) +++ libpanorama/trunk/src/parser/ChangeLog 2007-06-28 22:16:45 UTC (rev 2191) @@ -1,5 +1,18 @@ +2007-06-28 dmg <dm...@uv...> + + * parser.y, tparser.c, tparser.h: Implemented R variable in p-line + + * parser.y, tparser.c, tparser.h, scanner.l: Implemented Hugin + autoCenterCrop and cropFactor in i-lines. + 2007-06-27 dmg <dm...@uv...> + * parser.y, tparser.c, tparser.h, scanner.l: Implemented Ra...Re + variables and their references + + * parser.y, tparser.c, tparser.h: implemented hugin_options + variables r and e. + * Removed several debugging messages to make the output cleaner. * parser.y: Improved error handling in case of unrecognized Modified: libpanorama/trunk/src/parser/TODO =================================================================== --- libpanorama/trunk/src/parser/TODO 2007-06-28 21:44:08 UTC (rev 2190) +++ libpanorama/trunk/src/parser/TODO 2007-06-28 22:16:45 UTC (rev 2191) @@ -1,3 +1,4 @@ + * The parser needs to implement the 'v' lines * C and morph-to lines are to be tested @@ -3,3 +4,19 @@ * Implement variables r and e in hugin_options + r: optimizeReferenceImage + e: blendMode + + + +> #2. Also, there is a variable R in the pano line. What is it? it is the +> same as #hugin_options r0? + +No, it specifies the output mode: 0: LDR, 1: HDR + +> #3. Should I treat Ee, Er and Eb as an array of 3 values? if so, in +> which order? I will assume they are not linkable. + +Eev should be separate its the photographic Exposure Value. +Er and Eb are the white balance factors, I'd just keep the separate. + Modified: libpanorama/trunk/src/parser/parser.y =================================================================== --- libpanorama/trunk/src/parser/parser.y 2007-06-28 21:44:08 UTC (rev 2190) +++ libpanorama/trunk/src/parser/parser.y 2007-06-28 22:16:45 UTC (rev 2191) @@ -48,8 +48,19 @@ static pt_script_ctrl_point *ctrlPoint; static pt_script_morph_point *morphPoint; +// Look ahead variables +// Hugin uses a comment line _before_ the i line: for example +// #-hugin autoCenterCrop=1 cropFactor=1 +#define PT_AUTO_CENTER_CROP_ST "autoCenterCrop" +#define PT_AUTO_CENTER_CROP_DEFAULT 0 +static int autoCenterCrop = PT_AUTO_CENTER_CROP_DEFAULT; + +#define PT_CROP_FACTOR_ST "cropFactor" +#define PT_CROP_FACTOR_DEFAULT 0 +static int cropFactor = PT_CROP_FACTOR_DEFAULT; + /* copy a string while allocating and checking for memory */ static void ParserStringCopy(char **dest, char *from) { @@ -77,6 +88,7 @@ %token PT_TOKEN_SEP %token <fVal> PT_TOKEN_NUMBER %token <strVal> PT_TOKEN_STRING +%token <strVal> PT_TOKEN_HUGIN_KEYWORD %token <cVal> PT_TOKEN_KEYWORD %token <cVal> PT_TOKEN_CROPPING @@ -205,6 +217,13 @@ image = (pt_script_image *)panoScriptReAlloc((void*)&(script.inputImageSpec), sizeof(pt_script_image), &script.iInputImagesCount); + // This might require more though. Are the defaults of these two variables zero? + image->autoCenterCrop = autoCenterCrop; + image->cropFactor = cropFactor; + cropFactor = PT_CROP_FACTOR_DEFAULT; + autoCenterCrop = PT_AUTO_CENTER_CROP_DEFAULT; + + #ifdef asdfasf // allocate the new output script.iInputImagesCount++; @@ -244,8 +263,18 @@ huginVars: huginVar | huginVars PT_TOKEN_SEPARATOR huginVar -huginVar: - PT_TOKEN_HUGIN_KEYWORD PT_TOKEN_NUMBER +huginVar: PT_TOKEN_HUGIN_KEYWORD PT_TOKEN_NUMBER + { + // The tokens include the = at the end + // we could do a substr, but there is no real value on that + if (strcmp(PT_AUTO_CENTER_CROP_ST "=", $1) == 0) { + autoCenterCrop = lroundf($2); + } else if (strcmp(PT_CROP_FACTOR_ST "=" , $1) == 0) { + cropFactor = $2; + } else { + panoScriptParserError(1,"Warning: invalid variable %s found in Hugin image line. Ignored...\n", $1); + } + } vars: var | vars PT_TOKEN_SEPARATOR var @@ -294,8 +323,29 @@ case 't': image->coefIndex[6] = imageRef; break; + case 'R': // This is a hugin Ra,Rb, ...Re + // This is a hack. $1 is referenced as a char, but the next character is the + // a,b,c,d,e so let us get at it + { + char *temp = &$1; + temp++; + printf("string %c \n", *(temp)); + switch (*temp) { + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + image->responseCurveCoefIndex[(*temp)-'a'] = imageRef; + break; + default: + panoScriptParserError(1,"Invalid variable name R[%c] in image line...\n", *temp); + return -1; + } + } + break; default: - panoScriptParserError(1,"Invalid variable name [%c] in input line.\n", $1); + panoScriptParserError(1,"Invalid variable name [%c=] in input line.\n", $1); return -1; break; } @@ -367,7 +417,7 @@ ParserStringCopy(&image->name, $2); break; default: - panoScriptParserError(1,"Invalid variable name [%c] in image line..\n", $1); + panoScriptParserError(1,"Invalid variable name [%c] in image line...\n", $1); return -1; } break; @@ -383,10 +433,10 @@ case PT_TOKEN_HUGIN_OPTIONS_LINE: switch ($1) { case 'r': - printf("To do r hugin option\n"); + script.optimize.optimizeReferenceImage = lround($2); break; case 'e': - printf("To do e hugin option \n"); + script.optimize.blendMode = lround($2); break; default: panoScriptParserError(1, "Invalid variable name [%c] in hugin options line.\n", $1); @@ -418,7 +468,7 @@ ctrlPoint->type = $2; break; default: - panoScriptParserError(1, "Invalid variable name [%c] in input line.\n", $1); + panoScriptParserError(1, "Invalid variable name [%c] in control point line.\n", $1); return -1; break; } @@ -441,7 +491,7 @@ morphPoint->p2.y = $2; break; default: - panoScriptParserError(1, "Invalid variable name [%c] in input line.\n", $1); + panoScriptParserError(1, "Invalid variable name [%c] in morph line.\n", $1); return -1; break; } @@ -464,7 +514,7 @@ panoScriptParserError(1,"Invalid variable name [%c] in pano line. Ignored...\n", $1); break; case 'R': - panoScriptParserError(1,"Invalid variable name [%c] in pano line. Ignored...\n", $1); + script.pano.outputMode = lroundf($2); break; default: panoScriptParserError(1,"Invalid variable name [%c] in pano line\n", $1); @@ -514,6 +564,27 @@ case 'm': panoScriptParserError(1,"Warning: Option %c in image line deprecated. Ignored...\n", $1); break; + case 'R': // This is a hugin Ra,Rb, ...Re + // This is a hack. $1 is referenced as a char, but the next character is the + // a,b,c,d,e so let us get at it + { + char *temp = &$1; + temp++; + printf("string %c \n", *(temp)); + switch (*temp) { + case 'a': + case 'b': + case 'c': + case 'd': + case 'e': + image->responseCurveCoef[(*temp)-'a'] = $2; + break; + default: + panoScriptParserError(1,"Invalid variable name R[%c] in image line...\n", *temp); + return -1; + } + } + break; default: panoScriptParserError(1,"Invalid variable name [%c] in image line...\n", $1); return -1; Modified: libpanorama/trunk/src/parser/scanner.l =================================================================== --- libpanorama/trunk/src/parser/scanner.l 2007-06-28 21:44:08 UTC (rev 2190) +++ libpanorama/trunk/src/parser/scanner.l 2007-06-28 22:16:45 UTC (rev 2191) @@ -108,7 +108,7 @@ -[EKVR][0-9A-Za-z.=-]+[ \t]* { panoScriptScannerTokenBegin(yytext); } /* ignore K, V,R and E parameters */ +[EKV][0-9A-Za-z.=-]+[ \t]* { panoScriptScannerTokenBegin(yytext); } /* ignore K, V,R and E parameters */ /* These are the types of lines supported */ @@ -195,8 +195,15 @@ return PT_TOKEN_COMMA; } +R[abcde] { /* Hugin defines these variables in the i line */ + panoScriptScannerTokenBegin(yytext); + strncpy(yylval.strVal, yytext, PT_TOKEN_MAX_LEN); + return PT_TOKEN_KEYWORD; + } + + [CS] { - /*printf("Multi variable: %s\n", yytext); */ + /* These are the C and S parameters that contain multiple values */ strncpy(yylval.strVal, yytext, PT_TOKEN_MAX_LEN); return PT_TOKEN_CROPPING; } Modified: libpanorama/trunk/src/parser/testparser.c =================================================================== --- libpanorama/trunk/src/parser/testparser.c 2007-06-28 21:44:08 UTC (rev 2190) +++ libpanorama/trunk/src/parser/testparser.c 2007-06-28 22:16:45 UTC (rev 2191) @@ -44,19 +44,20 @@ script = panoScriptParse(argv[1], FALSE); - printf("\n\n-----------------Finished parsing\n"); - if (script == NULL) { printf("Parsing error\n"); } else { - panoScriptDump(script); - printf("-------------------------------------------------\n"); if (!panoScriptDeReferenceVariables(script)) { printf("Unable to de-reference all variable\n"); } + printf("\n\n-----------------Finished parsing\nValues after dereferencing\n\n"); + + panoScriptDump(script); + + /* printf("Printing after variables are dereferrenced\n"); Modified: libpanorama/trunk/src/parser/tparser.c =================================================================== --- libpanorama/trunk/src/parser/tparser.c 2007-06-28 21:44:08 UTC (rev 2190) +++ libpanorama/trunk/src/parser/tparser.c 2007-06-28 22:16:45 UTC (rev 2191) @@ -278,6 +278,12 @@ printf(" g %f", output->coef[5]); printf(" t %f\n", output->coef[6]); + printf(" Ra %f", output->responseCurveCoef[0]); + printf(" Rb %f", output->responseCurveCoef[1]); + printf(" Rc %f", output->responseCurveCoef[2]); + printf(" Rd %f", output->responseCurveCoef[3]); + printf(" Re %f\n", output->responseCurveCoef[4]); + printf(" name %s\n", output->name); printf(" cropType %c ", output->cropType); printf(" cropArea %i,%i,%i,%i ", @@ -292,7 +298,7 @@ printf(" yaw %d", output->yawIndex); printf(" pitch %d", output->pitchIndex); printf(" roll %d", output->rollIndex); - printf(" feather size %d", output->featherSize); + printf(" feather size %d\n", output->featherSize); printf(" a %d", output->coefIndex[0]); printf(" b %d", output->coefIndex[1]); @@ -302,6 +308,18 @@ printf(" g %d", output->coefIndex[5]); printf(" t %d\n", output->coefIndex[6]); + printf(" Ra %d", output->responseCurveCoefIndex[0]); + printf(" Rb %d", output->responseCurveCoefIndex[1]); + printf(" Rc %d", output->responseCurveCoefIndex[2]); + printf(" Rd %d", output->responseCurveCoefIndex[3]); + printf(" Re %d\n", output->responseCurveCoefIndex[4]); + + printf("Other parameters............."); + printf(" autoCenterCrop %d", output->autoCenterCrop); + printf(" cropFactor %f", output->cropFactor); + printf("\n"); + + printf(" Morphing points count %d\n", output->morphPointsCount); for (i=0;i<output->morphPointsCount;i++) { @@ -310,6 +328,7 @@ panoParserDumpMorphPoint(morphPoint); } + } /* @@ -338,6 +357,10 @@ for (i=0;i<script->pano.projectionParmsCount;i++) { printf(" proj parm %d: %f\n", i, script->pano.projectionParms[i]); } + printf("Hugin \n"); + printf(" output mode %d", script->pano.outputMode); + printf("\n"); + printf("Optimize .................."); printf(" gamma %f", script->optimize.fGamma); @@ -345,6 +368,9 @@ printf(" fastFT %d ", script->optimize.fastFT); printf(" huber estimator %d \n", script->optimize.huberEstimator); printf(" photometricHuberSigma %f \n", script->optimize.photometricHuberSigma); + printf(" optimize reference image %d \n", script->optimize.optimizeReferenceImage); + printf(" blend mode %d \n", script->optimize.blendMode); + printf("Output [%d] images ..................\n", script->iOutputImagesCount); @@ -464,6 +490,9 @@ for (j=0;j<PANO_PARSER_COEF_COUNT;j++) { UNLINK_VARIABLE(i,coef[j],coefIndex[j]); } + for (j=0;j<PANO_PARSER_RESP_CURVE_COEF_COUNT;j++) { + UNLINK_VARIABLE(i,responseCurveCoef[j],responseCurveCoefIndex[j]); + } } } #undef UNLINK_VARIABLE @@ -480,6 +509,9 @@ for (j=0;j<PANO_PARSER_COEF_COUNT;j++) { VERIFY_VARIABLE(i,coefIndex[j], names[j]); } + for (j=0;j<PANO_PARSER_RESP_CURVE_COEF_COUNT;j++) { + VERIFY_VARIABLE(i,responseCurveCoefIndex[j],names[j]); + } } #undef VERIFY_VARIABLE Modified: libpanorama/trunk/src/parser/tparser.h =================================================================== --- libpanorama/trunk/src/parser/tparser.h 2007-06-28 21:44:08 UTC (rev 2190) +++ libpanorama/trunk/src/parser/tparser.h 2007-06-28 22:16:45 UTC (rev 2191) @@ -46,6 +46,7 @@ #endif #define PANO_PARSER_COEF_COUNT 7 +#define PANO_PARSER_RESP_CURVE_COEF_COUNT 5 typedef struct { double x; @@ -77,6 +78,7 @@ float fHorFOV; char *outputFormat; char *outputPixelType; + int outputMode; } pt_script_pano; typedef struct { @@ -87,7 +89,8 @@ float yaw; float pitch; float roll; - float coef[7]; // a, b, c, d, e, g, t + float coef[PANO_PARSER_COEF_COUNT]; // a, b, c, d, e, g, t + float responseCurveCoef[PANO_PARSER_RESP_CURVE_COEF_COUNT]; // a b c d e char *name; char cropType ; // it can be 'S' or 'C' int cropArea[PANO_PARSER_COEF_COUNT]; // the rectangle to crop to @@ -99,9 +102,12 @@ int pitchIndex; int rollIndex; int coefIndex[PANO_PARSER_COEF_COUNT]; // a, b, c, d, e , g, t + int responseCurveCoefIndex[PANO_PARSER_RESP_CURVE_COEF_COUNT]; // a, b, c, d, e , g, t int featherSize; int morphPointsCount; pt_script_morph_point *morphPoints; + int autoCenterCrop; + float cropFactor; } pt_script_image; @@ -111,6 +117,8 @@ int fastFT; int huberEstimator; float photometricHuberSigma; + int optimizeReferenceImage; + int blendMode; } pt_script_optimize; typedef struct { This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dm...@us...> - 2007-06-28 22:42:00
|
Revision: 2192 http://hugin.svn.sourceforge.net/hugin/?rev=2192&view=rev Author: dmg Date: 2007-06-28 15:41:55 -0700 (Thu, 28 Jun 2007) Log Message: ----------- 2007-06-28 dmg <dm...@uv...> * tparser.h, tparser.h, tparser.c: Added all the variables needed by Hugin, renamed some of them. Modified Paths: -------------- libpanorama/trunk/src/parser/ChangeLog libpanorama/trunk/src/parser/parser.y libpanorama/trunk/src/parser/tparser.c libpanorama/trunk/src/parser/tparser.h Modified: libpanorama/trunk/src/parser/ChangeLog =================================================================== --- libpanorama/trunk/src/parser/ChangeLog 2007-06-28 22:16:45 UTC (rev 2191) +++ libpanorama/trunk/src/parser/ChangeLog 2007-06-28 22:41:55 UTC (rev 2192) @@ -1,5 +1,8 @@ 2007-06-28 dmg <dm...@uv...> + * tparser.h, tparser.h, tparser.c: Added all the variables needed + by Hugin, renamed some of them. + * parser.y, tparser.c, tparser.h: Implemented R variable in p-line * parser.y, tparser.c, tparser.h, scanner.l: Implemented Hugin Modified: libpanorama/trunk/src/parser/parser.y =================================================================== --- libpanorama/trunk/src/parser/parser.y 2007-06-28 22:16:45 UTC (rev 2191) +++ libpanorama/trunk/src/parser/parser.y 2007-06-28 22:41:55 UTC (rev 2192) @@ -404,7 +404,7 @@ ParserStringCopy(&script.pano.projectionParmsString, $2); break; case 'T': - ParserStringCopy(&script.pano.outputPixelType, $2); + ParserStringCopy(&script.pano.bitDepthOutput, $2); default: panoScriptParserError(1,"Invalid variable name [%c] in pano line\n", $1); return -1; @@ -514,7 +514,7 @@ panoScriptParserError(1,"Invalid variable name [%c] in pano line. Ignored...\n", $1); break; case 'R': - script.pano.outputMode = lroundf($2); + script.pano.dynamicRangeMode = lroundf($2); break; default: panoScriptParserError(1,"Invalid variable name [%c] in pano line\n", $1); Modified: libpanorama/trunk/src/parser/tparser.c =================================================================== --- libpanorama/trunk/src/parser/tparser.c 2007-06-28 22:16:45 UTC (rev 2191) +++ libpanorama/trunk/src/parser/tparser.c 2007-06-28 22:41:55 UTC (rev 2192) @@ -351,14 +351,14 @@ printf(" name %s ", script->pano.projectionName); printf(" fHorFOV %f ", script->pano.fHorFOV); printf(" format %s ", script->pano.outputFormat); - printf(" outputPixelType %s ", script->pano.outputPixelType); + printf(" bitDepthOutput %s ", script->pano.bitDepthOutput); printf(" proj parms %s\n", script->pano.projectionParmsString); printf(" proj parms count %d\n", script->pano.projectionParmsCount); for (i=0;i<script->pano.projectionParmsCount;i++) { printf(" proj parm %d: %f\n", i, script->pano.projectionParms[i]); } printf("Hugin \n"); - printf(" output mode %d", script->pano.outputMode); + printf(" output mode %d", script->pano.dynamicRangeMode); printf("\n"); @@ -610,7 +610,7 @@ FREE(ptr->pano.projectionParmsString); FREE(ptr->pano.outputFormat); - FREE(ptr->pano.outputPixelType); + FREE(ptr->pano.bitDepthOutput); for (i=0;i<ptr->iOutputImagesCount;i++) { FREE(ptr->outputImageSpec[i].name); Modified: libpanorama/trunk/src/parser/tparser.h =================================================================== --- libpanorama/trunk/src/parser/tparser.h 2007-06-28 22:16:45 UTC (rev 2191) +++ libpanorama/trunk/src/parser/tparser.h 2007-06-28 22:41:55 UTC (rev 2192) @@ -47,6 +47,7 @@ #define PANO_PARSER_COEF_COUNT 7 #define PANO_PARSER_RESP_CURVE_COEF_COUNT 5 +#define PANO_PARSER_VIGN_COEF_COUNT 6 typedef struct { double x; @@ -76,9 +77,13 @@ char *projectionParmsString; char *projectionName; float fHorFOV; - char *outputFormat; - char *outputPixelType; - int outputMode; + char *outputFormat; // n : file format of output + + // Hugin parameters + int dynamicRangeMode; // R[01] 0 -> LDR; 1 -> HDR + char *bitDepthOutput; // T bitdepth of output images, possible values are + //XXX TO BE IMPLEMENTED + float exposureValue; // E exposure value of final panorama } pt_script_pano; typedef struct { @@ -89,8 +94,29 @@ float yaw; float pitch; float roll; + + int featherSize; float coef[PANO_PARSER_COEF_COUNT]; // a, b, c, d, e, g, t - float responseCurveCoef[PANO_PARSER_RESP_CURVE_COEF_COUNT]; // a b c d e + + + // These are hugin parameters + int autoCenterCrop; + float cropFactor; + + // Exposure related + /// XXXXXXXXX TO BE IMPLEMENTED + float imageEV; // Exposure value of image Eev + float whiteBalanceFactorRed; // Er + float whiteBalanceFactorBlue; // Eb + + /// XXXXXXXXX TO BE IMPLEMENTED + int responseCurveType; // Ry 0 -> EMoR, 1 -> linear + float responseCurveCoef[PANO_PARSER_RESP_CURVE_COEF_COUNT]; // R[abcde] + + /// XXXXXXXXX TO BE IMPLEMENTED + int vignettingCorrectionMode; // Vm + float vignettingCorrectionCoef[PANO_PARSER_VIGN_COEF_COUNT]; // V[abcdxy] + char *name; char cropType ; // it can be 'S' or 'C' int cropArea[PANO_PARSER_COEF_COUNT]; // the rectangle to crop to @@ -101,13 +127,20 @@ int yawIndex; int pitchIndex; int rollIndex; + // hugin indexes for de-referencing + // XXXXXX to be done + int imageEVIndex; //Exposure value of image + float whiteBalanceFactorRedIndex; // Er + float whiteBalanceFactorBlueIndex; // Eb + int vignettingCorrectionModeIndex; // Vm + int vignettingCorrectionCoefIndex[PANO_PARSER_VIGN_COEF_COUNT]; // V[abcdxy] + int coefIndex[PANO_PARSER_COEF_COUNT]; // a, b, c, d, e , g, t - int responseCurveCoefIndex[PANO_PARSER_RESP_CURVE_COEF_COUNT]; // a, b, c, d, e , g, t - int featherSize; + int responseCurveCoefIndex[PANO_PARSER_RESP_CURVE_COEF_COUNT]; // R[abcde] + + // Morphing Points int morphPointsCount; pt_script_morph_point *morphPoints; - int autoCenterCrop; - float cropFactor; } pt_script_image; This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dm...@us...> - 2007-06-29 06:09:59
|
Revision: 2193 http://hugin.svn.sourceforge.net/hugin/?rev=2193&view=rev Author: dmg Date: 2007-06-28 23:09:20 -0700 (Thu, 28 Jun 2007) Log Message: ----------- 2007-06-28 dmg <dm...@uv...> * parser.y, tparser.c, tparser.h, scanner.l: I think I finished implementing all the hugin specific parameters. Modified Paths: -------------- libpanorama/trunk/src/parser/ChangeLog libpanorama/trunk/src/parser/parser.y libpanorama/trunk/src/parser/scanner.l libpanorama/trunk/src/parser/tparser.c libpanorama/trunk/src/parser/tparser.h Modified: libpanorama/trunk/src/parser/ChangeLog =================================================================== --- libpanorama/trunk/src/parser/ChangeLog 2007-06-28 22:41:55 UTC (rev 2192) +++ libpanorama/trunk/src/parser/ChangeLog 2007-06-29 06:09:20 UTC (rev 2193) @@ -1,5 +1,8 @@ 2007-06-28 dmg <dm...@uv...> + * parser.y, tparser.c, tparser.h, scanner.l: I think I finished + implementing all the hugin specific parameters. + * tparser.h, tparser.h, tparser.c: Added all the variables needed by Hugin, renamed some of them. Modified: libpanorama/trunk/src/parser/parser.y =================================================================== --- libpanorama/trunk/src/parser/parser.y 2007-06-28 22:41:55 UTC (rev 2192) +++ libpanorama/trunk/src/parser/parser.y 2007-06-29 06:09:20 UTC (rev 2193) @@ -123,7 +123,6 @@ DEBUG_2("Number of control points %d", script.iMorphPointsCount); for (i = 0; i < script.iMorphPointsCount; i++) { - fprintf(stderr, "abc************************************\n"); // get a pointer to the point to make life easier morphPoint = &morphPointsSpec[i]; image = morphPoint->iImage; @@ -329,7 +328,6 @@ { char *temp = &$1; temp++; - printf("string %c \n", *(temp)); switch (*temp) { case 'a': case 'b': @@ -344,6 +342,29 @@ } } break; + case 'V': // This is a hugin Va, Vb, Vc, Vd, Vx, Vy + // This is a hack. $1 is referenced as a char, but the next character is the + // a,b,c,d,e so let us get at it + { + char *temp = &$1; + temp++; + switch (*temp) { + case 'a': + case 'b': + case 'c': + case 'd': + image->vignettingCorrectionCoefIndex[(*temp)-'a'] = imageRef; + break; + case 'x': + case 'y': + image->vignettingCorrectionCoefIndex[(*temp)-'x'+4] = imageRef; + break; + default: + panoScriptParserError(1,"Invalid variable name V[%c] in image line...\n", *temp); + return -1; + } + } + break; default: panoScriptParserError(1,"Invalid variable name [%c=] in input line.\n", $1); return -1; @@ -511,13 +532,13 @@ script.pano.fHorFOV = $2; break; case 'E': - panoScriptParserError(1,"Invalid variable name [%c] in pano line. Ignored...\n", $1); + script.pano.exposureValue = $2; break; case 'R': script.pano.dynamicRangeMode = lroundf($2); break; default: - panoScriptParserError(1,"Invalid variable name [%c] in pano line\n", $1); + panoScriptParserError(1,"Error Invalid variable name [%c] in pano line\n", $1); return -1; } break; @@ -564,14 +585,16 @@ case 'm': panoScriptParserError(1,"Warning: Option %c in image line deprecated. Ignored...\n", $1); break; - case 'R': // This is a hugin Ra,Rb, ...Re + case 'R': // This is a hugin Ry, Ra,Rb, ...Re // This is a hack. $1 is referenced as a char, but the next character is the // a,b,c,d,e so let us get at it { char *temp = &$1; temp++; - printf("string %c \n", *(temp)); switch (*temp) { + case 'y': + image->responseCurveType = lroundf($2); + break; case 'a': case 'b': case 'c': @@ -585,6 +608,47 @@ } } break; + case 'E': + { + char *temp = &$1; + temp++; + if (strcmp(temp, "ev") == 0) { + image->imageEV = $2; + } else if (strcmp(temp, "r") == 0) { + image->whiteBalanceFactorRed = $2; + } else if (strcmp(temp, "b") == 0) { + image->whiteBalanceFactorBlue = $2; + } else { + panoScriptParserError(1,"Invalid variable name E[%c] in image line...\n", *temp); + } + } + break; + case 'V': // This is a hugin Va, Vb, Vc, Vd, Vx, Vy + // This is a hack. $1 is referenced as a char, but the next character is the + // a,b,c,d,e so let us get at it + { + char *temp = &$1; + temp++; + switch (*temp) { + case 'm': + image->vignettingCorrectionMode = lroundf($2); + break; + case 'a': + case 'b': + case 'c': + case 'd': + image->vignettingCorrectionCoef[(*temp)-'a'] = $2; + break; + case 'x': + case 'y': + image->vignettingCorrectionCoef[(*temp)-'x'+4] = $2; + break; + default: + panoScriptParserError(1,"Invalid variable name V[%c] in image line...\n", *temp); + return -1; + } + } + break; default: panoScriptParserError(1,"Invalid variable name [%c] in image line...\n", $1); return -1; @@ -625,7 +689,7 @@ case PT_TOKEN_PANO_LINE: switch ($1) { case 'T': - panoScriptParserError(1,"Warning: T parameter expects a string parameter. None provided. Ignored\n", $1); + ParserStringCopy(&script.pano.bitDepthOutput, ""); break; default: panoScriptParserError(1,"Invalid variable name [%c] in pano line\n", $1); Modified: libpanorama/trunk/src/parser/scanner.l =================================================================== --- libpanorama/trunk/src/parser/scanner.l 2007-06-28 22:41:55 UTC (rev 2192) +++ libpanorama/trunk/src/parser/scanner.l 2007-06-29 06:09:20 UTC (rev 2193) @@ -107,10 +107,9 @@ time being just ignore them */ +[K][0-9A-Za-z.=-]+[ \t]* { panoScriptScannerTokenBegin(yytext); } /* ignore K parameters */ -[EKV][0-9A-Za-z.=-]+[ \t]* { panoScriptScannerTokenBegin(yytext); } /* ignore K, V,R and E parameters */ - /* These are the types of lines supported */ ^o { panoScriptScannerTokenBegin(yytext); @@ -194,7 +193,20 @@ panoScriptScannerTokenBegin(yytext); return PT_TOKEN_COMMA; } +E[erb]v? { /* Hugin defines these variables in the i line */ + panoScriptScannerTokenBegin(yytext); + strncpy(yylval.strVal, yytext, PT_TOKEN_MAX_LEN); + return PT_TOKEN_KEYWORD; + } +V[mabcdxy] { /* Hugin defines these variables in the i line */ + panoScriptScannerTokenBegin(yytext); + strncpy(yylval.strVal, yytext, PT_TOKEN_MAX_LEN); + return PT_TOKEN_KEYWORD; + } + + + R[abcde] { /* Hugin defines these variables in the i line */ panoScriptScannerTokenBegin(yytext); strncpy(yylval.strVal, yytext, PT_TOKEN_MAX_LEN); Modified: libpanorama/trunk/src/parser/tparser.c =================================================================== --- libpanorama/trunk/src/parser/tparser.c 2007-06-28 22:41:55 UTC (rev 2192) +++ libpanorama/trunk/src/parser/tparser.c 2007-06-29 06:09:20 UTC (rev 2193) @@ -277,13 +277,9 @@ printf(" e %f", output->coef[4]); printf(" g %f", output->coef[5]); printf(" t %f\n", output->coef[6]); + - printf(" Ra %f", output->responseCurveCoef[0]); - printf(" Rb %f", output->responseCurveCoef[1]); - printf(" Rc %f", output->responseCurveCoef[2]); - printf(" Rd %f", output->responseCurveCoef[3]); - printf(" Re %f\n", output->responseCurveCoef[4]); - + printf("Other parameters.............\n"); printf(" name %s\n", output->name); printf(" cropType %c ", output->cropType); printf(" cropArea %i,%i,%i,%i ", @@ -291,35 +287,70 @@ output->cropArea[1], output->cropArea[2], output->cropArea[3]); - printf(" morphToFit %d\n", output->morphToFit); + printf(" morphToFit %d", output->morphToFit); + printf(" feather size %d", output->featherSize); - printf(" References: "); + printf("\nHugin parameters\n"); + + printf(" autoCenterCrop %d", output->autoCenterCrop); + printf(" cropFactor %f", output->cropFactor); + printf("\n image ev %f", output->imageEV); + printf(" whiteBalanceFactorRed %f", output->whiteBalanceFactorRed); + printf(" whiteBalanceFactorBlue %f", output->whiteBalanceFactorBlue); + printf("\n responseCurveType %d", output->responseCurveType); + + printf(" Ra %f", output->responseCurveCoef[0]); + printf(" Rb %f", output->responseCurveCoef[1]); + printf(" Rc %f", output->responseCurveCoef[2]); + printf(" Rd %f", output->responseCurveCoef[3]); + printf(" Re %f\n", output->responseCurveCoef[4]); + + printf("\n Vignetting Correction Mode %d", output->vignettingCorrectionMode); + printf(" Va %f", output->vignettingCorrectionCoef[0]); + printf(" Vb %f", output->vignettingCorrectionCoef[1]); + printf(" Vc %f", output->vignettingCorrectionCoef[2]); + printf(" Vd %f", output->vignettingCorrectionCoef[3]); + printf(" Vx %f", output->vignettingCorrectionCoef[4]); + printf(" Vy %f", output->vignettingCorrectionCoef[5]); + + + printf("\nLinked attributes\n"); printf(" fHorFOV %d", output->fHorFOVIndex); printf(" yaw %d", output->yawIndex); printf(" pitch %d", output->pitchIndex); printf(" roll %d", output->rollIndex); - printf(" feather size %d\n", output->featherSize); - printf(" a %d", output->coefIndex[0]); + printf("\n a %d", output->coefIndex[0]); printf(" b %d", output->coefIndex[1]); printf(" c %d", output->coefIndex[2]); printf(" d %d", output->coefIndex[3]); printf(" e %d", output->coefIndex[4]); printf(" g %d", output->coefIndex[5]); printf(" t %d\n", output->coefIndex[6]); - - printf(" Ra %d", output->responseCurveCoefIndex[0]); + + printf("Hugin linked parameters\n"); + + printf(" imageEVIndex %d", output->imageEVIndex); + printf(" whiteBalanceFactorRedIndex %d", output->whiteBalanceFactorRedIndex); + printf(" whiteBalanceFactorBlueIndex %d", output->whiteBalanceFactorBlueIndex); + + printf("\n Va %d", output->vignettingCorrectionCoefIndex[0]); + printf(" Vb %d", output->vignettingCorrectionCoefIndex[1]); + printf(" Vc %d", output->vignettingCorrectionCoefIndex[2]); + printf(" Vd %d", output->vignettingCorrectionCoefIndex[3]); + printf(" Vx %d", output->vignettingCorrectionCoefIndex[4]); + printf(" Vy %d", output->vignettingCorrectionCoefIndex[5]); + + + printf("\n Ra %d", output->responseCurveCoefIndex[0]); printf(" Rb %d", output->responseCurveCoefIndex[1]); printf(" Rc %d", output->responseCurveCoefIndex[2]); printf(" Rd %d", output->responseCurveCoefIndex[3]); printf(" Re %d\n", output->responseCurveCoefIndex[4]); - printf("Other parameters............."); - printf(" autoCenterCrop %d", output->autoCenterCrop); - printf(" cropFactor %f", output->cropFactor); + printf("\n"); - printf(" Morphing points count %d\n", output->morphPointsCount); for (i=0;i<output->morphPointsCount;i++) { @@ -357,9 +388,6 @@ for (i=0;i<script->pano.projectionParmsCount;i++) { printf(" proj parm %d: %f\n", i, script->pano.projectionParms[i]); } - printf("Hugin \n"); - printf(" output mode %d", script->pano.dynamicRangeMode); - printf("\n"); printf("Optimize .................."); @@ -367,9 +395,15 @@ printf(" interpolator %d", script->optimize.interpolator); printf(" fastFT %d ", script->optimize.fastFT); printf(" huber estimator %d \n", script->optimize.huberEstimator); + + printf("Hugin Parameters\n"); + printf(" dynamic range mode %d", script->pano.dynamicRangeMode); + printf(" exposureValue %f", script->pano.exposureValue); + printf(" photometricHuberSigma %f \n", script->optimize.photometricHuberSigma); printf(" optimize reference image %d \n", script->optimize.optimizeReferenceImage); printf(" blend mode %d \n", script->optimize.blendMode); + printf("\n"); printf("Output [%d] images ..................\n", script->iOutputImagesCount); @@ -493,6 +527,13 @@ for (j=0;j<PANO_PARSER_RESP_CURVE_COEF_COUNT;j++) { UNLINK_VARIABLE(i,responseCurveCoef[j],responseCurveCoefIndex[j]); } + UNLINK_VARIABLE(i,imageEV, imageEVIndex); + UNLINK_VARIABLE(i,whiteBalanceFactorRed, whiteBalanceFactorRedIndex); + UNLINK_VARIABLE(i,whiteBalanceFactorBlue, whiteBalanceFactorBlueIndex); + UNLINK_VARIABLE(i,vignettingCorrectionMode,vignettingCorrectionModeIndex); + for (j=0;j<PANO_PARSER_VIGN_COEF_COUNT;j++) { + UNLINK_VARIABLE(i,vignettingCorrectionCoef[j],vignettingCorrectionCoefIndex[j]); + } } } #undef UNLINK_VARIABLE Modified: libpanorama/trunk/src/parser/tparser.h =================================================================== --- libpanorama/trunk/src/parser/tparser.h 2007-06-28 22:41:55 UTC (rev 2192) +++ libpanorama/trunk/src/parser/tparser.h 2007-06-29 06:09:20 UTC (rev 2193) @@ -104,16 +104,13 @@ float cropFactor; // Exposure related - /// XXXXXXXXX TO BE IMPLEMENTED float imageEV; // Exposure value of image Eev float whiteBalanceFactorRed; // Er float whiteBalanceFactorBlue; // Eb - /// XXXXXXXXX TO BE IMPLEMENTED int responseCurveType; // Ry 0 -> EMoR, 1 -> linear float responseCurveCoef[PANO_PARSER_RESP_CURVE_COEF_COUNT]; // R[abcde] - /// XXXXXXXXX TO BE IMPLEMENTED int vignettingCorrectionMode; // Vm float vignettingCorrectionCoef[PANO_PARSER_VIGN_COEF_COUNT]; // V[abcdxy] @@ -127,15 +124,16 @@ int yawIndex; int pitchIndex; int rollIndex; + int coefIndex[PANO_PARSER_COEF_COUNT]; // a, b, c, d, e , g, t + // hugin indexes for de-referencing - // XXXXXX to be done + int imageEVIndex; //Exposure value of image - float whiteBalanceFactorRedIndex; // Er - float whiteBalanceFactorBlueIndex; // Eb + int whiteBalanceFactorRedIndex; // Er + int whiteBalanceFactorBlueIndex; // Eb int vignettingCorrectionModeIndex; // Vm int vignettingCorrectionCoefIndex[PANO_PARSER_VIGN_COEF_COUNT]; // V[abcdxy] - int coefIndex[PANO_PARSER_COEF_COUNT]; // a, b, c, d, e , g, t int responseCurveCoefIndex[PANO_PARSER_RESP_CURVE_COEF_COUNT]; // R[abcde] // Morphing Points This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <dm...@us...> - 2007-06-28 00:10:55
|
Revision: 2174 http://hugin.svn.sourceforge.net/hugin/?rev=2174&view=rev Author: dmg Date: 2007-06-27 17:10:53 -0700 (Wed, 27 Jun 2007) Log Message: ----------- 2007-06-27 dmg <dm...@uv...> * parser.y: Improved error handling in case of unrecognized lines. Previously it was stopping at the first line it did not recognized, but returned no error. * parser.y, tparser.c, tparser.h (struct): Added parameters outputPixelType and photometricHuberSigma. Added feather size (u) in images lines * scanner.l: Added token for #-hugin variables. Modified Paths: -------------- libpanorama/trunk/src/parser/ChangeLog libpanorama/trunk/src/parser/parser.y libpanorama/trunk/src/parser/scanner.l libpanorama/trunk/src/parser/tparser.c libpanorama/trunk/src/parser/tparser.h Modified: libpanorama/trunk/src/parser/ChangeLog =================================================================== --- libpanorama/trunk/src/parser/ChangeLog 2007-06-27 20:44:20 UTC (rev 2173) +++ libpanorama/trunk/src/parser/ChangeLog 2007-06-28 00:10:53 UTC (rev 2174) @@ -1,3 +1,15 @@ +2007-06-27 dmg <dm...@uv...> + + * parser.y: Improved error handling in case of unrecognized + lines. Previously it was stopping at the first line it did not + recognized, but returned no error. + + * parser.y, tparser.c, tparser.h (struct): Added parameters + outputPixelType and photometricHuberSigma. Added feather size (u) + in images lines + + * scanner.l: Added token for #-hugin variables. + 2007-06-14 dmg <dm...@uv...> * parser.y (PT_TOKEN_STRING): Removed yydebug for the time being. Modified: libpanorama/trunk/src/parser/parser.y =================================================================== --- libpanorama/trunk/src/parser/parser.y 2007-06-27 20:44:20 UTC (rev 2173) +++ libpanorama/trunk/src/parser/parser.y 2007-06-28 00:10:53 UTC (rev 2174) @@ -90,8 +90,11 @@ %token PT_TOKEN_COMMA %token PT_TOKEN_REFERENCE %token PT_TOKEN_MORPH_PT_LINE +%token PT_TOKEN_HUGIN_LINE +%token PT_TOKEN_HUGIN_OPTIONS_LINE +%token PT_TOKEN_HUGIN_KEYWORD +%token PT_TOKEN_ERROR - %start input %% /* Grammar rules and actions follow. */ @@ -149,9 +152,32 @@ | optimizeline | ctrlPtsLine | morphPtsLine + | huginImageParmsLine + | huginOptionsLine + | parsingError ; +parsingError: PT_TOKEN_ERROR +{ + return -1; +} PT_TOKEN_SEPARATOR ; + +huginOptionsLine: PT_TOKEN_HUGIN_OPTIONS_LINE PT_TOKEN_SEPARATOR + { + currentLine = PT_TOKEN_HUGIN_OPTIONS_LINE; + } vars eoln + + +huginImageParmsLine: PT_TOKEN_HUGIN_LINE PT_TOKEN_SEPARATOR + { + currentLine = PT_TOKEN_HUGIN_LINE; + } + huginVars + eoln { ; } +// + + ctrlPtsLine: PT_TOKEN_CONTROL_PT_LINE PT_TOKEN_SEPARATOR { currentLine = PT_TOKEN_CONTROL_PT_LINE; @@ -215,6 +241,12 @@ panoline: PT_TOKEN_PANO_LINE PT_TOKEN_SEPARATOR { currentLine=PT_TOKEN_PANO_LINE; } vars eoln { ; } +huginVars: huginVar + | huginVars PT_TOKEN_SEPARATOR huginVar + +huginVar: + PT_TOKEN_HUGIN_KEYWORD PT_TOKEN_NUMBER + vars: var | vars PT_TOKEN_SEPARATOR var @@ -321,6 +353,8 @@ case 'P': ParserStringCopy(&script.pano.projectionParmsString, $2); break; + case 'T': + ParserStringCopy(&script.pano.outputPixelType, $2); default: panoScriptParserError(1,"Invalid variable name [%c] in pano line\n", $1); return -1; @@ -346,6 +380,20 @@ { /* Processing of int variables */ switch (currentLine) { + case PT_TOKEN_HUGIN_OPTIONS_LINE: + switch ($1) { + case 'r': + printf("To do r hugin option\n"); + break; + case 'e': + printf("To do e hugin option \n"); + break; + default: + panoScriptParserError(1, "Invalid variable name [%c] in hugin options line.\n", $1); + return -1; + break; + } + break; case PT_TOKEN_CONTROL_PT_LINE: switch ($1) { case 'n': @@ -461,8 +509,10 @@ image->coef[6] = $2; break; case 'u': + image->featherSize = lroundf($2); + break; case 'm': - printf("Option %c in image line deprecated. Ignored...\n", $1); + panoScriptParserError(1,"Warning: Option %c in image line deprecated. Ignored...\n", $1); break; default: panoScriptParserError(1,"Invalid variable name [%c] in image line...\n", $1); @@ -484,7 +534,7 @@ script.optimize.huberEstimator = lround($2); break; case 'p': - panoScriptParserError(1,"Obsolete variable name [%c] in optimize line. Ignored...\n", $1); + script.optimize.photometricHuberSigma = $2; break; default: panoScriptParserError(1,"Invalid variable name [%c] in optimize line\n", $1); @@ -492,7 +542,7 @@ } break; default: - panoScriptParserError(1,"Error. Not handled (token int [%c]\n", $1); + panoScriptParserError(1,"Error. Not handled (token int [%c])\n", $1); return -1; } } @@ -504,7 +554,7 @@ case PT_TOKEN_PANO_LINE: switch ($1) { case 'T': - panoScriptParserError(1,"Invalid variable name [%c] in pano line. Ignored...\n", $1); + panoScriptParserError(1,"Warning: T parameter expects a string parameter. None provided. Ignored\n", $1); break; default: panoScriptParserError(1,"Invalid variable name [%c] in pano line\n", $1); Modified: libpanorama/trunk/src/parser/scanner.l =================================================================== --- libpanorama/trunk/src/parser/scanner.l 2007-06-27 20:44:20 UTC (rev 2173) +++ libpanorama/trunk/src/parser/scanner.l 2007-06-28 00:10:53 UTC (rev 2174) @@ -62,6 +62,7 @@ %x str %x parm +%x hugin %% @@ -99,12 +100,14 @@ /* Tokens to ignore */ -^v.*\n { ; } /* Ignore v lines */ +^v.*\n { ; } /* Ignore v lines TODO XXXXXXXXXXXX*/ /* Hugin specific variables. When they are supported it would be easier to generate a new type of token for them. For the time being just ignore them */ + + [EKVR][0-9A-Za-z.=-]+[ \t]* { panoScriptScannerTokenBegin(yytext); } /* ignore K, V,R and E parameters */ @@ -129,6 +132,51 @@ return PT_TOKEN_OPTIMIZE_LINE; } +^"#hugin_options" { + panoScriptScannerTokenBegin(yytext); + return PT_TOKEN_HUGIN_OPTIONS_LINE; + } + +^"#-hugin" { + panoScriptScannerTokenBegin(yytext); + BEGIN(hugin); + return PT_TOKEN_HUGIN_LINE; + } + +<hugin>[ \t]+ { /*printf("skypping separator\n"); */ + panoScriptScannerTokenBegin(yytext); + inVariable = 0; + return PT_TOKEN_SEPARATOR; + } + + +<hugin>{ID}+= { + panoScriptScannerTokenBegin(yytext); + strncpy(yylval.strVal, yytext, PT_TOKEN_MAX_LEN); + return PT_TOKEN_HUGIN_KEYWORD; + } + +<hugin>[ \t]*\n { + BEGIN(INITIAL); + return PT_TOKEN_EOL; + } + +<hugin>-?{DIGIT}+ { + /* printf( "An integer: %s (%d)\n", yytext, atoi( yytext ) );*/ + panoScriptScannerTokenBegin(yytext); + yylval.fVal = atof( yytext ); + return PT_TOKEN_NUMBER; + } + +<hugin>-?{DIGIT}+"."{DIGIT}* { + /*printf( "A float: %s (%g)\n", yytext, atof( yytext ) );*/ + panoScriptScannerTokenBegin(yytext); + yylval.fVal = atof( yytext ); + return PT_TOKEN_NUMBER; + } + + + ^c { panoScriptScannerTokenBegin(yytext); return PT_TOKEN_CONTROL_PT_LINE; @@ -190,7 +238,8 @@ panoScriptScannerTokenBegin(yytext); return PT_TOKEN_REFERENCE; } -"#".+\n /* eat up comments */ + +"# ".+\n /* eat up comments */ { ; } @@ -236,7 +285,7 @@ . { panoScriptParserError(1,"Unrecognized character: %s\n", yytext ); - return 0; + return PT_TOKEN_ERROR; } %% Modified: libpanorama/trunk/src/parser/tparser.c =================================================================== --- libpanorama/trunk/src/parser/tparser.c 2007-06-27 20:44:20 UTC (rev 2173) +++ libpanorama/trunk/src/parser/tparser.c 2007-06-28 00:10:53 UTC (rev 2174) @@ -102,7 +102,7 @@ vsprintf(errmsg, errorstring, args); va_end(args); - fprintf(stdout, "Error: %s\n", errmsg); + fprintf(stdout, "%s\n", errmsg); // exit } @@ -292,6 +292,7 @@ printf(" yaw %d", output->yawIndex); printf(" pitch %d", output->pitchIndex); printf(" roll %d", output->rollIndex); + printf(" feather size %d", output->featherSize); printf(" a %d", output->coefIndex[0]); printf(" b %d", output->coefIndex[1]); @@ -331,6 +332,7 @@ printf(" name %s ", script->pano.projectionName); printf(" fHorFOV %f ", script->pano.fHorFOV); printf(" format %s ", script->pano.outputFormat); + printf(" outputPixelType %s ", script->pano.outputPixelType); printf(" proj parms %s\n", script->pano.projectionParmsString); printf(" proj parms count %d\n", script->pano.projectionParmsCount); for (i=0;i<script->pano.projectionParmsCount;i++) { @@ -342,6 +344,7 @@ printf(" interpolator %d", script->optimize.interpolator); printf(" fastFT %d ", script->optimize.fastFT); printf(" huber estimator %d \n", script->optimize.huberEstimator); + printf(" photometricHuberSigma %f \n", script->optimize.photometricHuberSigma); printf("Output [%d] images ..................\n", script->iOutputImagesCount); @@ -576,6 +579,7 @@ FREE(ptr->pano.projectionParmsString); FREE(ptr->pano.outputFormat); + FREE(ptr->pano.outputPixelType); for (i=0;i<ptr->iOutputImagesCount;i++) { FREE(ptr->outputImageSpec[i].name); Modified: libpanorama/trunk/src/parser/tparser.h =================================================================== --- libpanorama/trunk/src/parser/tparser.h 2007-06-27 20:44:20 UTC (rev 2173) +++ libpanorama/trunk/src/parser/tparser.h 2007-06-28 00:10:53 UTC (rev 2174) @@ -76,6 +76,7 @@ char *projectionName; float fHorFOV; char *outputFormat; + char *outputPixelType; } pt_script_pano; typedef struct { @@ -98,6 +99,7 @@ int pitchIndex; int rollIndex; int coefIndex[PANO_PARSER_COEF_COUNT]; // a, b, c, d, e , g, t + int featherSize; int morphPointsCount; pt_script_morph_point *morphPoints; } pt_script_image; @@ -108,6 +110,7 @@ int interpolator; int fastFT; int huberEstimator; + float photometricHuberSigma; } pt_script_optimize; typedef struct { This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |