Generating Encryption Keys from Biometric Fingerprint Templates How would one go about generating Encryption Keys from Biometric Fingerprint Templates extracted from a fingerprint using either Griaule SDK or DigitalPersona SDK or any other SDK that will return the fingerprint template in either ISO or ANSI fingerprint templates format? Is there a way one would do that using Fuzzy Extractors, Secure Sketch, Bio Hashing or any other approach? I will appreciate if anyone can show me how to go about this in any programming language? I intend to use the obtained Encryption Keys in encryption and decryption of data.
There is a pretty good introductory book that strongly relates to the topic area: Security with Noisy Data that I would recommend you take a look at. The book has constructions for how you would do this (turn fingerprint readings into keys), information on different adversary models you might consider, and information on related topic areas.

I am not familiar with either of the SDKs you mention, or the formats. So, for the sake of simplicity, I'll assume that each time you read the fingerprint, you get back a binary string. Since the scanners are not perfect, each time you read from it, you will get back a slightly different binary string. Let $\rho$ be the maximum error rate you see between binary strings which come from scanning the same fingerprint. One chapter in the book (which is freely available here) gives constructions for how you can generate and publish some helper data which can be stored in plaintext. This helper data allows you to recover the original key so that you can, for example, decrypt.

Let $C$ be an $[n, k, 2t+1]$ linear error  correction code defined over some finite field $\mathcal{F}$. $t$ is the number of errors that can be corrected, so we need  $t$ to be large enough to  correct $n\rho$ errors. The syndrome construction for secure sketches works as follows. 

We have 2 phases (enrollment and reconstruction or GEN and REP). GEN: Let $H$ be the parity check metric of $C$. We take a sample from the reader to get the binary string representing the fingerprint, call it $w$. The length of $w$ is $n$. Let $H$ be the parity check matrix of $C$, we compute the syndrome of $w$ as $wH=s$. We then run $w$ through an extractor (e.g., a hash function) to get the key. We publish $s$ publicly as the helper data.

REP: At some later point in time, we want to reconstruct the key (do do a decryption or further encryption). This time we take another sample using the reader and get $w'$. We decode $w'$ using $s$ to get back $w$, and rerun $w$ through the extractor to get the key. As long as the hamming distance between $w$ and $w'$ is less than or equal to $t$ we are guaranteed to get the same key. For more information on coding, and some source code, see here.

In practice there can be issues. The helper data $s$ leaks information. So, to get 80 bits of security, $w$ is going to have to be larger than 80 bits long. Using the syndrome construction, we can quantify the amount of information leaked by $s$. It is $n-k$ which happens to also be the length of $s$. I am not sure what the error rate is for fingerprint scans or the entropy rate. It could very well be that by the time we have published $s$ there is no usable entropy left. Recent work tries to deal with this case. But, if the error rate is too high, and the number bits in a single fingerprint is too low, we could be in a case where there is just not enough entropy to get a strong key. Therefore, you really need to analyze and think about if this will work. Theoretical constructions are there, but physical limitations might make it impossible.