Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 7 years ago.
Improve this question
So I'm doing some research related to High Dynamic Range Imaging (HDRI). I've already done some work in OpenCV related to aligning and ghost removal (no actual HDR manipulation or creation yet), and now I would like to be able to start working with HDR images.
Can anyone recommend a good open source HDR library that would ideally allow me to do the following:
Read/ Write an HDR format (I'm not commited to a particular format yet, so I'm open to suggestions here)
Combine exposure-bracketed images to get HDR images, but in a way that allows me to access the camera function that gets created so that I can later use this to do things like using different numbers of EB images to contribute to different parts of the HDR image.
Interface relatively easily with OpenCV (see below for details).
If it's a library that allows easy interfacing with OpenCV, that would be ideal. I don't think there is currently any HDR functionality in OpenCV, but can anyone tell me if there's a way to convert an HDR image into a format that OpenCV algorithns such as inpainting will work with? For example, I know OpenCV can work with 64-bit floating point images; can I just convert an HDR image into one of these formats and run with it?
Thanks.
Hey, I asked this a long time ago, and just stumbled on my question again through google, so I thought I'd provide a quick update.
I tried Image Magick with Magick++. After a fair bit of work, I managed to get it working with OpenEXR format, but was never able to get Radiance (.hdr) working which is a shame because I do a lot of work in MATLAB which only reads/writes Radiance for HDR.
Next, I tried FreeImage. I was able to read/write hdr as well as PFM formats with this, but I found the Fibitmap format really closed, i.e. difficult to get data from a fibitmap into an OpenCV Mat, and near impossible to get it back into a Fibitmap.
In the end, I just started using Portable Float Maps (PFMs), and reading and writing them with my own code because the format is so simple. Again, this is in a research setting, so while PFM is a pretty ungainly format for long-term storange or commercial use, it's pretty nice for research purposes.
I am using FreeImage library to load HDR images (this library supports most raw camera formats, floating-point image types, and 48bpp, 64bpp images).
Then I did a converter class in C++ that is able to convert from FreeImage-type images to OpenCV and vice-versa. FreeImage also has tone-mapping conversions to change HDR images to 32bpp images.
I would say converting would probably just be easiest. I would look at the imagemagick (http://www.imagemagick.org) libraries for conversion.
Related
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Questions asking us to recommend or find a tool, library or favorite off-site resource are off-topic for Stack Overflow as they tend to attract opinionated answers and spam. Instead, describe the problem and what has been done so far to solve it.
Closed 8 years ago.
Improve this question
I have tried using ProR to create an ReqIF document. It is cumbersome and contains a lot of bugs, since it is in its alpha state now. Another constraint that I have right now is that I cannot use proprietary software like IBM Rational DOORS. Are there any other such tools to generate ReqIF documents? Are there any alternatives to ProR?
I am the project lead on the Eclipse ProR project, and I am sorry to hear that ProR is not yet up to it for your needs.
As far as I know, there is not even commercial support for ReqIF available (please correct me if I am wrong). DOORS currently only supports RIF 1.2. Also, please keep in mind that ReqIF 1.0.1 only got released in April 2011 - that's not even a year. It takes time to write software. :-)
A possible alternative for you may be to use a RIF tool and to write yourself an XSLT script to transform RIF into ReqIF.
Another alternative is to work with RIF 1.1 or RIF 1.2 for the time being. There are many commercial tools supporting that standard, although I am not aware of a single one that is free.
The third (and to me preferred) option would be if you could give ProR another chance, and help to improve it. Specifically, if you could give us clear, reproducible bug reports, that would be fabulous. Also, it would be incredible useful if we knew how you plan on using ProR (what are your use cases?). We are actively working on ProR right now, and respond fairly quickly.
Here is the link to file a ProR Bug in Bugzilla
The best place to discuss usage and use cases is the RMF Forum
And last, for reference, the ProR project web page
Shriram,
RIF 1.2 files generated in DOORS 9.x do not conform to the schema - that's at least what we have experienced at a customer site.
If you want to transform RIF 1.1a, 1.2 or XLS to ReqIF (and vice-versa), you might want to try http://www.pyrrho.com/en/ReqIF/ReqIF-Intro.htm. They run an online conversion service, which is currently free - I do not know what the future plans are.
I have heard from a colleague that the User Interface of Pyrrho is not quite intuitive, but I have tried it and it works. The XLS to RIF/ReqIF transformation is still limited, as all datatypes are interpreted as strings, so far. It is generated from the models, so it should be complete, otherwise.
Our tool, the ReqIF Server (http://www.reqif.de), is free for university projects, but not complete enough to create a reqif file from scratch. You can edit existing ones, though. Or convert RIF 1.1a to 1.2 and vice versa.
Best regards, Oskar
I am project member of the ERA ReqIF editor.
We have implemented an EMF/Ecore representation of a subset of the ReqIF model.
Still, we store files primarily in EMF XML format.
Our little converter to ReqIF XML format is yet a prototype and very alpha (because we focus on our user-configurable GUI...).
In conclusion, ERA will not help you, yet. But I just wanted to let you know.
Probably you are interested in tracking our project in the future.
(We are a small private team and it will take us some time.)
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 6 years ago.
Improve this question
I am working with a client to revive his old software which was developed around 14 years ago using Foxpro2.6.
My problem is that client just have the source code (in the form of .prg files)and database files with him but there is neither any documentation nor comments in source code to guide me what does what...even the database files are not correctly named.
My only option in this scenario seems to go through the .prg files and understand which command updates which database record and how....but there are around 300 .prg files and I don't know Fox Pro at all (I mean I was in 9th standard when this thing became obsolete!!).
Any suggestion or idea to make this work easy, perhaps a .prg to C converter which can help me a lot.
Please help....it is becoming a nightmare
PS : I dont have problem with the database conversion but the front end and functional source code which too is written in the FoxPro2.6 and saved as .prg extension is the problem as I dont know the language and there is no documentation.
In reality, you will need to rewrite the application from scratch.
The first thing I would advise to do is to convert a copy of the project to the last version of Visual FoxPro (9 SP2), then at least you have an IDE to work in and some basic tools like search / replace, and reformatting source code to make it more readable.
See http://www.alvechurchdata.co.uk/foxconvert.htm for basic details on conversion. Note that if the original program used third-party or custom libraries (e.g. .fll files) then you won't
be able to run the converted program.
FoxPro 2.6 is a straightforward enough procedural language: unfortunately it is (almost) inevitable that the program logic will be mixed in with the window (screen) definitions and behaviour, and as SQL is built into the language then the data access will all be mixed in there as well.
If contracting someone with more experience to do the conversion is no option, then you might as well just dive in - there are still plenty of people who know FoxPro2.6 to help out when you get stuck: start from the main program and see where it goes from there.
As Stuart mentioned, conversions and such... I actually do Foxpro / Visual Foxpro and work with another individual who would be able to contract with you to help jump-start and wrap your head around the conversion and quick analysis of what's really going on.
Yes, old .prg files are somewhat simple, but even back in the old FoxBase, FoxPlus, Foxpro Windows days, there were a lot of ugly coders out there. If you are interested, let me know. I've been doing Fox since before Microsoft bought it...
There's an foxdoc.exe in FP2.6, when run, you will have full documentation which prg it calls and which dbf it uses. Hope this helps
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 9 years ago.
Improve this question
I want to ask about the different techniques they used to remember various programming techniques. We go through various books and various online tips and tutorials we also get so many ideas from the code written by somebody else.
Now all these inputs are memorized or stored in some format so that it can be found easily when referred. Absence of such storage may result in rewriting the code or reinventing the wheel.
I use to create one Working folder where I keep all my trial code but sometime after few days / months since the code is not tagged or named properly its difficult to find it out again.
For Perl, I have a module I call staging.pm, and use staging; is a pragma in my code which allows me to use experimental, not fully developed code in my development. This developmental code will be placed in a branch called "staging" off of the user library directory. The main thing that the module does is put my staging directory at the head of #INC. Once my code is mature--if it ever is--it will be moved into my user lib directory.
As for scripts, they can be run from wherever they are and I use a directory named test off of the bin directory.
So that's kind of my approach. I don't know how useful that is for you.
It's like learning any other language or learning any other technique. When you read a book and you find it interesting you start associating what you are reading with real life situations and problems that you might have had before which the new learnt stuff will solve for you.
You might, after a couple of days or so forget what you have learned, untill you stumble upon the problem which you related to when reading the book or looking at the lecture. This specific type of memory is called something like association memory technique.
There are a lot of other different techniques to remember things by but a lot of them come down to relationships with other parts of what you already know.
Another example is Math which is something you force your brain to understand but once you quit using it on a daily basis you will slowly degenerate the math-genious-cells.
Programming for me at least is just another way to express myself and when i learn new features it's just a new way to express things that might not have been easy to do before.
Edit
I might have missunderstood the question.. did i?
Well, for me, when I am trying to learn, I focus on learning the approach to solve the program, rather than a technique. That is important to me. Also, with regular day to day programming some techniques become ingrained.
The other thing I do is to maintain a notebook with my notes in it, code snippets, comments, shortcuts I have learnt over the years. This helps too.
Recently I have taken to maintaining my notes in Evernote, this makes is easy to search for and tag.
For web, I use Delicious + Firefox plugin to store what I already read.
When looking for a solution to something I can't solve, I got used to ask / search here.
And for my own solutions, I try to create reusable components and remember in which project I solved what and eventually get back to it later when I need it.
Whenever you study one programming technique like java you always map the corresponding things with C++ and perl.Java and C++ remain same in more concepts.And better you store your working folder in your mails so that whenever you need you can download and have it.
You could try a program like Surfulater. I don't know how well it works with code samples, but I do know that the developer was (is still?) active on the Joel on Software forums, so I'm sure he could be contacted with any specific questions.
If you use Windows, you can use Google Desktop to index part of your harddrive, including your program snippets.
If you can recall just some of it, Google will find it.
(Spotlight does the same automatically on a Mac)
On Mac OS X, TextMate provides a near perfect solution to this problem. TextMate is a programming editor that offers support for hundreds of programming languages and is customizable via the bundle editor. Through the bundle editor, you can add any snippet of code that you may want to memorize, and appropriately categorize it under its respective language. You can also assign hot-keys or character sequences to invoke a snippet and copy it to your current editing context.
I believe that Notepad++ is a similar tool for Windows, but I am unsure if it is as customizable as TextMate.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.
Closed 8 years ago.
Improve this question
Reading well-written code seems to help me learn a language. (At least it worked with C.) [deleting the 'over-specified' part of the question]
I'm interested in particular in lisp's reputation as a language suited to creating a mini-language or DSL specific to a problem. The program ought to be open-source, of course, and available over the web, preferably.
I've Googled and found this example:
http://lispm.dyndns.org/news?ID=NEWS-2005-07-08-1
Anybody have another? (And, yes, I will continue reading "Practical Common Lisp".)
After 11 hours (only 11 hours!): Thanks, everyone. What a wonderful site, and what a bunch of good answers and tips!
I feel your constraints are over-specified:
small enough to comprehend, varied
enough to show off most of (c)lisp's
tricks and features without being
opaque (the 'well-written' part of the
wish), and independent of other
packages.
Common Lisp is a huge language, and the power set that emerges when you combine the language elements is much larger. You can't have a small program showing "most tricks" in CL.
There are also many concepts that you will find alien when you learn CL coming from another language. As such CL is less about tricks but more about its fundamental paradigms.
My suggestion is to read up on it a bit first and then start building your own programs or looking into open source code.
Edi Weitz for example usually writes good code. Check out his projects at http://www.weitz.de/.
And now go read PCL. :)
I'm kind of lazy to find the links, but you should be able to 'Google'/'Bing' it. The following list mentions very different ways to embed languages and very different embedded languages.
ITERATE for iterations
System/Module/File description in 'defsystem's, an example would be ASDF
infix readmacro
define-application-frame in CLIM for specifying user interfaces
embedded Lispified SQL queries in LispWorks and CLSQL
Knowledgeworks of LispWorks: logic language with rules, queries, ...
embedded Prolog in Allegro CL
embedded HTML in various forms
XMLisp, integrates XML and Lisp
Screamer for non-deterministic programming
PWGL, visual programming for composing music
Note that there are simple embedded languages and really complex ones that are providing whole new paradigms like Prolog, Screamer, CORBA, ...
If you haven't taken a look at it yet, the book Practical Common Lisp is available free online and has several example projects.
The LOOP macro is an almost perfect example of a DSL embedded in Common Lisp. However, since it's already part of the standard, it may not be what you're after.
CLs format function have a mini dsl.
http://cybertiggyr.com/fmt/
I think that dsl for printing strings will compile to machine code.
(format nil "~{~A~#[~:;, ~]~}" lst))
CLSQL provides a Lispy notation for SQL queries, which it compiles to SQL, and just about all Lisp HTML and XML generation libraries qualify. Metabang bind is a DSL for lexically binding variables. You probably didn't know you needed one, but it turns out to be amazingly useful.
SERIES is kind of a DSL, depending on your definition. It's in an appendix to CLTL2, though it's not actually part of the language.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 4 years ago.
Improve this question
After every new program written a lot of paper documentation remains.
Apart from the usual scribble notes from the programmers there usually is a nice heap of papers containing physical model explanations, calculations and so on (equations, tables, graphs, little pictures describing variables ...)
We usually do numerically intensive calculations in console applications, which are not released to the public (remain in the house, only results go out). Before each project is finished all those papers have to be packed somehow with the application, so that one day, when someone will be reusing parts of it, has some idea what is what in there.
So far, we've been using the 'dirty' solution of just scanning all of it, and packing it up on the disc with the application.
So I was wondering ... for all science guys here in a similar situation ... how do you handle project documentation which is needed, but not released to the public ?
(the one that does, goes to the dtp laddies, and they make it nice and shiny - not our problem anymore :)
I use one of three options:
Keep everything in my lab notebooks, which I archive myself, for low-level stuff
Scan the paper document, and add to source control in pdf. It's ugly, but if someone needs it, it's there
Transcribe the equations, results, etc... in a clean format (usually Latex) for future reference, and again, add to source control. Official paper copy gets signed (I work in a highly regulated domain) and filed in a binder.
In the projects I've worked on we have done a lot of physics calculations in our programs and consequently we have a lot of whiteboard sessions with equations we are working on.
We keep a wiki for each major project and after each whiteboard session we physically photograph the whiteboard with a digital camera and upload/organize it within the wiki. We also scan in paper documents from developers notebooks if it is important and include it in the wiki as well.
Then, we back up the wiki on disc for storage. So our solution is pretty similar to yours, other than we use the project wiki for organization.
If it's important, it seems to me you should treat the internal documentation with the same care with which you treat the public docs.
I create UI paper prototypes when designing the UI of an application, which produces lots of A3-sized papers (in one project we had many desks covered with papers). When the design is ready or it needs to be mailed to somebody, I take pictures of it with a digital camera, so that I can produce a series of pictures showing how to perform some tasks on the UI, which serves as documentation of how the application is meant to work. This serves also as a backup, in case somebody steals/cleans away the original papers.
Here is some of the thoughts... Not so practical though :)
We can make it part of our Check-in notes. This may help the developers going to maintain the application.
Update the requirement document/Low level design document with these items