Moon Kim
Page Banner

United States Department of Agriculture

Agricultural Research Service

Selected Publications
headline bar
<P><A class=toolNav href="/ba/emfsl/moonkim"><I>www.ars.usda.gov/ba/emfsl/moonkim</I></A> </P> 
<P><STRONG>Moon S. Kim, Ph.D.<BR>Research Physicist</STRONG> </P> 
<P>USDA, ARS, BA, BARC, EMFSL<BR>10300 Baltimore Ave.<BR>Building 303 BARC-East, Room 001A<BR>Beltsville, MD 20705-2350 USA<BR>phone: 301.504.8450 ext 245<BR>fax: 301.504.9466<BR><A class=toolNav href="mailto:moon.kim@ars.usda.gov">moon.kim@ars.usda.gov</A> </P> 
<HR align=left color=#000080 width="100%"> 

<P>In the lists below, the clickable <IMG border=0 hspace=0 alt="PDF icon" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17>&nbsp;icon indicates that a publication can be opened in PDF format. A PDF reading program, such as the <A href="http://get.adobe.com/reader/">free Adobe Acrobat Reader®</A>, is needed to view the PDF files on this page. </P> 
<P>A <A href="/pandp/people/publications.htm?personid=3003">list of publications drawn from the ARS database for Moon Kim</A>&nbsp;is also available, with access to an abstract/summary for each publication.</FONT> </P> 
<HR align=left color=#000080 width="100%"> 

<H1 align=center><FONT color=#006666><A class=toolNav href="#2000">2000</A> | <A class=toolNav href="#2001">2001</A> | <A class=toolNav href="#2002">2002</A> | <A class=toolNav href="#2003">2003</A> | <A class=toolNav href="#2004">2004</A> <BR><A class=toolNav href="#2005">2005</A> | <A class=toolNav href="#2006">2006</A> | <A class=toolNav href="#2007">2007</A> | <A class=toolNav href="#2008">2008</A> | <A class=toolNav href="#2009">2009</A> <BR><A class=toolNav href="#2010">2010</A> | <A class=toolNav href="#2011">2011</A> | <A class=toolNav href="#2012">2012</A> | <A class=toolNav href="#2013">2013</A> | <A class=toolNav href="#2014">2014</A> <BR><A class=toolNav href="#Patents">Patents</A> </FONT></H1> 
<H1><A name=Patents></A><FONT color=#006666>Patents</FONT></STRONG> </H1> 
<OL> 
<LI><STRONG>Kim, M.S.</STRONG>, Chao, K., Bannon, D. Method of determining histamine concentration in fish. USPTO, Utility Patent application submitted. September 2013. USPTO Notice of allowance, July 10, 2015.  
<LI><STRONG>Kim, M.S.</STRONG>, Chao, K., Cho, B.K., and Lee, K. Single-camera multi-mirror imaging method and apparatus for whole-surface inspection of rotating objects. US Patent # 8,988,523 B1. USPTO, March 24, 2015.  
<LI><A href="/SP2UserFiles/person/3003/PATENT 8625856 B2.pdf" target=_blank><IMG border=0 hspace=0 alt="Click here to view or download PDF file" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Chao, K., Chen, Y.R., <STRONG>Kim, M.S.</STRONG>, Chan, E., and Yang, C. Method and system for wholesomeness inspection of freshly slaughtered chickens on a processing line. US Patent # 8,625,856. USPTO, January 7, 2014.  
<LI><A href="/SP2UserFiles/person/3003/PATENT 8467052 B1.pdf" target=_blank><IMG border=0 hspace=0 alt="Click here to view or download PDF file" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Chao, K., <STRONG>Kim, M.S.</STRONG>, Lefcourt, Tuschel, D., Olkhovyk, O, and Liu, Y. Systems and Methods for Detecting Contaminants in a Sample. US Patent #, 8,467,052. USPTO, June 18, 2013.  
<LI><A href="/SP2UserFiles/person/3003/PATENT 8310544 B2.pdf" target=_blank><IMG border=0 hspace=0 alt="Click here to view or download PDF file" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;<STRONG>Kim, M.S.</STRONG>, Lefcourt, A., Chao, K., Chen, Y.R., Senecal, A., Marek, P. Hand-held inspection tool and method. US Patent #8,310,544 B2. USPTO, Nov 7, 2012.  
<LI><A href="/SP2UserFiles/person/3003/PATENT 8126213 B2.pdf" target=_blank><IMG border=0 hspace=0 alt="Click here to view or download PDF file" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Chao, K., Chen, Y.R., <STRONG>Kim, M.S.</STRONG>, Chan, E., and Yang, C. Method and system for wholesomeness inspection of freshly slaughtered chickens on a processing line. US Patent # 8,126,213. USPTO, Feb. 28, 2012.  
<LI><A href="/SP2UserFiles/person/3003/PATENT 7787111 B2.pdf" target=_blank><IMG border=0 hspace=0 alt="Click here to view or download PDF file" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;<STRONG>Kim, M.S.</STRONG>, Chen, Y., Chao, K., and Lefcourt, A.M. Simultaneous acquisition of fluorescence and reflectance imaging techniques with a single imaging device for multitask inspection. US Patent # 7,787,111, USPTO. Aug. 31, 2010.  
<LI><A href="/SP2UserFiles/person/3003/PATENT 7547508 B1.pdf" target=_blank><IMG border=0 hspace=0 alt="Click here to view or download PDF file" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Lefcourt, A.M., <STRONG>Kim, M.S.</STRONG>, and Chen, Y.R. Use of Nanosecond Scale, Time-Resolved, Imaging to Differentiate Contemporaneous Fluorescence Responses For Multiple Substances. US Patent, #7,547,508. USPTO. June 16, 2009.  
<LI><A href="/SP2UserFiles/person/3003/PATENT 7460227 B1.pdf" target=_blank><IMG border=0 hspace=0 alt="Click here to view or download PDF file" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;<STRONG>Kim, M.S.</STRONG>, Lefcourt, A.M., and Chen, Y.R. Method to detect exposed bone fragments during processing of meat or fish. US Patent #7,460,227, USPTO. Dec. 2, 2008. <BR><BR> 
<LI><I>(Pending)</I> Schmidt, W.F., <STRONG>Kim, M.S.</STRONG>, Chao, K., Shelton, D.R. Variable temperature thermodynamic Raman spectroscopy method and apparatus. USPTO, Provisional Patent application submitted. January 2015.  
<LI><I>(Pending)</I> Chao, K., <STRONG>Kim, M.S.</STRONG>, and Qin, J. Line-scan Raman imaging method and apparatus for rapid evaluation of large samples. USPTO, Utility Patent application submitted October 2013.  
<LI><I>(Pending)</I> <STRONG>Kim, M.S.</STRONG>, Chao, K., Lefcourt, A., Lee, K., Kang, S., and Chan, D. Single-camera angled conveyance imaging method and apparatus for whole-surface inspection of rotating objects. USPTO, Utility Patent application submitted. March 2013. </LI></OL> 
<H1><A name=2014></A><FONT color=#006666>2014 (peer-reviewed)</FONT></H1> 
<OL> 
<LI>Barnaby, J.Y., Sicher, R., <STRONG>Kim, M.S.</STRONG>, and Reddy, V.R. Carbon dioxide enrichment restrains the impact of drought on three maize hybrids differing in water stress tolerance in water stressed environments. Int. J. of Plant Biology, 5(5535):38-44. 2014.  
<LI><A href="/SP2UserFiles/person/3003/ChaoK2014ComputerStdsAndInterfaces36_271.pdf" target=_blank><IMG border=0 hspace=0 alt="Click here to view or download PDF file" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Chao, K., <STRONG>Kim, M.S.</STRONG>, and Chan, D., Control Interface and Tracking Control System for Automated Poultry Inspection. Computers Standards and Interfaces, 36 (2): 271-277. 2014. <A href="http://dx.doi.org/10.1016/j.csi.2011.03.006" target=_blank>doi:10.1016/j.csi.2011.03.006</A>  
<LI>Everard, C., <STRONG>Kim, M.S.</STRONG>, and Lee, H. A comparison of hyperspectral reflectance and fluorescence imaging techniques for detection of contaminants on leafy greens. J. Food Engineering, 143:139-145. 2014.  
<LI>Everard, C., <STRONG>Kim, M.S.</STRONG>, Lee, H., and O’Donnell, C. Hyperspectral fluorescence imaging coupled with multivariate image analysis techniques for detection of fecal contamination on spinach leaves. Food and Bioprocess Technology, in press. 2014.  
<LI>Le, H.D., <STRONG>Kim, M.S.</STRONG>, Hwang, J., Yang, Y., U-Thainual, P., Kang, J.U., and Kim, D.H. An average enumeration method of hyperspectral imaging data for quantitative evaluation of medical device surface contamination. J. Biomedical Optics, 5(10): 3613-3627. 2014.  
<LI>Lee, H.S., <STRONG>Kim, M.S.</STRONG>, Jeong, D., Delwiche, S., Chao, K., and Cho, B. Detection of cracks on tomatoes using hyperspectral near-infrared reflectance imaging system. Sensors, 14(10): 18837-18850. 2014.  
<LI>Lee, H.Y., Everard, C., Kang, S., Cho, B., Chao, K., Chan, D., and <STRONG>Kim, M.S.</STRONG> Multispectral fluorescence imaging for detection of bovine feces on Romaine lettuce and baby spinach leaves. Biosystems Engineering, 127:125-134. 2014.  
<LI><A href="/SP2UserFiles/person/3003/LeeH2014JBiosystemsEng39_142.pdf" target=_blank><IMG border=0 hspace=0 alt="Click here to view or download PDF file" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Lee, H.Y., Yang, C.C., <STRONG>Kim, M.S.</STRONG>, Lim, J., Cho, B., Chao, K., and Lefcourt, A.M., and Everard, C. A simple multispectral imaging algorithm for detection of defects on Red Delicious apples. J. of Biosystems Engineering, 39(2):142-149. 2014. <A href="http://dx.doi.org/10.5307/JBE.2014.39.2.142" target=_blank>doi:10.5307/JBE.2014.39.2.142</A>  
<LI><A href="/SP2UserFiles/person/3003/LeeWH2014JFoodEng130_1.pdf" target=_blank><IMG border=0 hspace=0 alt="Click here to view or download PDF file" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Lee, W.H., <STRONG>Kim, M.S.</STRONG>, Lee, H., Delwiche, S., Bae, H., Kim, D.Y., and Cho, B. Hyperspectral near-infrared imaging for the detection of physical damages of pear. J. Food Engineering, 130:1-7. 2014. <A href="http://dx.doi.org/10.1016/j.jfoodeng.2013.12.032" target=_blank>doi:10.1016/j.jfoodeng.2013.12.032</A>  
<LI>Lim, J.G., Mo, C., Kim, G. Kang, S., Lee, K.J, <STRONG>Kim, M.S.</STRONG>, and Moon, H. Non-destructive and rapid prediction of moisture content in red pepper (Capsicum annuum L.) powder using near-infrared spectroscopy and a partial least squares regression model. J. Biosystems Eng., 39(3):184-193. 2014.  
<LI>Lohumi, S., Lee, S., Lee, W.H., <STRONG>Kim, M.S.</STRONG>, Mo, C., Bae, B., and Cho, B.K. Detection of starch adulteration in onion powder by FT-NIR and FT-IR spectroscopy. J. Ag. Food Chemistry, 62:9246–9251. 2014.  
<LI><A href="/SP2UserFiles/person/3003/MoCetAl2014Sensors14.pdf" target=_blank><IMG border=0 hspace=0 alt="Click here to view or download PDF file" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Mo, C., Kim, G., Lee, K., <STRONG>Kim, M.S.</STRONG>, Cho, B., Lim, J., and Kang, S. Non-destructive quality evaluation of pepper (Capsicum annuum L.) seeds using LED-induced hyperspectral reflectance imaging, Sensors, 14: 7489-7504. 2014. <A href="http://dx.doi.org/10.3390/s140407489" target=_blank>doi:10.3390/s140407489</A>  
<LI>Qin, J., Chao, K., Cho, B., Peng, Y., and <STRONG>Kim, M.S.</STRONG> High-throughput Raman chemical imaging for rapid evaluation of food safety and quality. Trans. ASABE, 57(6):1783-1792. 2014.  
<LI>Qin, J., Chao, K., and <STRONG>Kim, M.S.</STRONG> A line-scan hyperspectral system for high-throughput Raman chemical imaging. Applied Spectroscopy. 68 (6): 692-695. 2014. <A href="https://www.s-a-s.org/journal/viewer/abstract/11273/" target=_blank><I>abstract</I></A>  
<LI>Qin, J., Chao, K., <STRONG>Kim, M.S.</STRONG>, Lee, H.Y., and Peng, Y. Development of a Raman chemical imaging detection method for authenticating skim milk powder. J. Food Measurement and Characterization, 8 (2): 122-131. 2014. <A href="http://dx.doi.org/10.1007/s11694-014-9172-9" target=_blank>doi:10.1007/s11694-014-9172-9</A>  
<LI>Rao, X., Yang, C.C., Ying, Y., <STRONG>Kim, M.S.</STRONG>, Chan, D., and Chao, K. Differentiation of deciduous-calyx Korla fragrant pears using NIR hyperspectral imaging analysis. Trans. ASABE, 57(6):1875-1883. 2014.  
<LI><A href="/SP2UserFiles/person/3003/SchmidtWetAl2014JAgFoodChem62.pdf"><IMG border=0 hspace=0 alt="Click here to view or download PDF file" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Schmidt, W.F., Hapeman, C. J., McConnell, L. L., Mookherji, S., Nguyen, J.K., Qin, J., Lee, H., Chao, K., and <STRONG>Kim, M.S.</STRONG> Temperature-dependent Raman spectroscopic evidence of and molecular mechanism for irreversible isomerization of β-endosulfan to α-endosulfan. J. Ag. Food Chem., 62:2023-2030. 2014. <A href="http://dx.doi.org/10.1021/jf404404w" target=_blank>doi:10.1021/jf404404w</A>  
<LI><A href="/SP2UserFiles/person/3003/ShiltsP2014TransASABE.pdf"><IMG border=0 hspace=0 alt="Click here to view or download PDF file" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Shilts, P., Motabar, P., Lefcourt, A.M., <STRONG>Kim, M.S.</STRONG>, and Tasch, U. Homogenization optics to improve detectability of a fluorescence response to a single laser pulse: Detection of feces on apples. Trans. ASABE 57(2): 615-622. 2014. <A href="http://dx.doi.org/10.13031/trans.57.10443" target=_blank>doi:10.13031/trans.57.10443</A>  
<LI>Yang, C.C., <STRONG>Kim, M.S.</STRONG>, Millner, P., Chao, K., Cho, B., Mo, C., Lee, H., and Chan, D. Multispectral image algorithms for the detection of frass on mature tomatoes. Postharvest Biology and Technology, 93:1-8. 2014. </LI></OL> 
<P style="TEXT-ALIGN: right"><I><A class=toolNav href="#top">go back to the top</A></I> </P> 
<H1><A name=2013></A><FONT color=#006666>2013 (peer-reviewed)</FONT> </H1> 
<OL> 
<LI>Barnaby, J.Y., <STRONG>Kim, M.S.</STRONG>, Bauchan, G.R., Bunce, J., Vangimalla, R., and Sicher, R. Drought responses of foliar metabolites in three maize hybrid lines differing in water stress tolerance. PLoS ONE 8(10): e77145. 2013.  
<LI>Cho, B, <STRONG>Kim, M.S.</STRONG>, Baek, I., Kim, D., Kim, Y., Lee, W., Kim, J, Bae, H, and Kim, Y. Detection of cuticle defects on cherry tomatoes based on hyperspectral fluorescence imagery. Postharvest Biology and Technology, 76:40-49. 2013.  
<LI>Delwiche, S.R., Souza, E., and <STRONG>Kim, M.S.</STRONG> Near-infrared hyperspectral imaging for milling quality of soft wheat. Biosystems Engineering, 115:260-273. 2013.  
<LI>Fu, X., <STRONG>Kim, M.S.</STRONG>, Chao, K., Qin, J., Lim, J., Lee, H., Garrido-Varo, A., Martinez, P., and Ying, Y. Detection of melamine in milk powders based on NIR hyperspectral imaging and spectral similarity analyses. J. Food Engineering, 124: 97-104. 2013.  
<LI>Jung, D. <STRONG>Kim, M.S.</STRONG>, Chao, K., Lee, H., Lee, H.Y., and Cho, B. Detection algorithm for cracks on the surface of tomatoes using multispectral Vis/NIR reflectance imagery. J. of Biosystems Eng., 38(3): 199-207. 2013.  
<LI>Kandpal, L., Lee, H., <STRONG>Kim, M.S.</STRONG>, and Cho, B. Hyperspectral reflectance imaging technique for visualization of moisture distribution in cooked chicken breast. Sensors, 13:13289-13300. 2013.  
<LI>Lee, H., Cho, B., <STRONG>Kim, M.S.</STRONG>, Lee, W.H., Tewari, J., Bae, H., Sohn, S., and Chi, Y. Prediction of crude protein and oil content of soybeans using Raman spectroscopy. Sensors and Actuators B, 185:694-700. 2013.  
<LI>Lefcourt, A.M., Wiederoder, M., <STRONG>Kim, M.S.</STRONG>, Lo, Y., and Liu, N. Development of a portable hyperspectral imaging system for monitoring the efficacy of sanitation procedures in food processing facilities. J. Food Engineering, 117(1):59-66. 2013.  
<LI>Lefcourt, A.M., Wiederoder, M., <STRONG>Kim, M.S.</STRONG>, Lo, Y., and Liu, N. Use of a portable hyperspectral imaging system for monitoring the efficacy of sanitation procedures in produce processing plants. J. Food Engineering, 117(2): 217-216. 2013.  
<LI>Lim, J., <STRONG>Kim, M.S.</STRONG>, Baek, I., Mo, C., Lee, H., Kang, S., Lee, K., and Kim, G. Non-destructive prediction of low levels of melamine particles in milk powder using hyperspectral reflectance imaging and partial least square regression model. Food Engineering Progress, 17(4): 377-386. 2013.  
<LI>Mo, C., Lee, K., Lim, J.G., <STRONG>Kim, M.S.</STRONG>, Kang, S.W., Lee, H.D., Kim, D.Y., Bae, H, and Cho B.K. Development of a non-destructive pungency measurement system for red-pepper powder. J. Fac. Agr., Kyushu Univ., 58 (1):137-144. 2013.  
<LI>Mo, C., Lim, J., Lee, K., Kang, S., <STRONG>Kim, M.S.</STRONG>, Kim, G., and Cho, B. Determination of germination quality of cucumber (Cucumis sativus) seed by LED-induced hyperspectral reflectance imaging. J. of Biosystems Eng., 38(4): 318-326. 2013.  
<LI>Qin, J., Chao, K., and <STRONG>Kim, M.S.</STRONG> Simultaneous detection of multiple adulterants in dry milk using macro-scale Raman chemical imaging. Food Chemistry, 138:998-1007. 2013.  
<LI>Qin, J., Chao, K., <STRONG>Kim, M.S.</STRONG>, Lu, R., and Burks, T. Hyperspectral and multispectral imaging for evaluating food safety and quality. Computers and Electronics in Agriculture. 118:157-171. 2013.  
<LI>Yang, C.C., <STRONG>Kim, M.S.</STRONG>, Cho, B., Lee, H., Chao, K., Lee, H., Jeong, D., Lefcourt, A.M., and Chan, D. Development of multispectral algorithms for detection of cracked tomatoes. Trans. ASABE, 56(4): 1581-1588. 2013. </LI></OL> 
<P style="TEXT-ALIGN: right"><I><A class=toolNav href="#top">go back to the top</A></I> </P> 
<H1><A name=2012></A><FONT color=#006666>2012 (peer-reviewed)</FONT></H1> 
<OL> 
<LI>Ahn, C.K., Baek, I.S., Mo, C., <STRONG>Kim, M.S.</STRONG>, and Cho, B.K. Development of non-destructive quality measurement technique for cabbage seed (Brassica campestris L) using hyperspectral reflectance imaging. Food Engineering Progress, 16(3):257-262. 2012.  
<LI>Kim, J., <STRONG>Kim, M.S.</STRONG>, and Cho, B.K. Fluorescence based spectral assessment of pork meat freshness. Food Engineering Progress, 16(3):249-256. 2012.  
<LI><STRONG>Kim, M.S.</STRONG>, Delwiche, S.R., Chao, K., Garrido-Varo, A., Perez-Marin, D., Lefcourt, A.M., and Chan, D. Visible to SWIR hyperspectral imaging for produce safety and quality evaluation. J. Sensing and Instrumentation for Food Quality and Safety, 5:155-164. 2012.  
<LI>Kim, T., Lee, H., <STRONG>Kim, M.S.</STRONG>, and Cho B.K. Optimal optical filters of fluorescence excitation and emission for poultry fecal detection. J. of Biosystems Eng., 37(4):265-270. 2012.  
<LI>Qin, J., Chao, K., and <STRONG>Kim, M.S.</STRONG> Nondestructive evaluation of internal maturity of tomatoes using spatially offset Raman spectroscopy. Postharvest Biology and Technology, 71: 21-31. 2012.  
<LI>Wiederoder, M., Lefcourt, A., <STRONG>Kim, M.S.</STRONG>, and Lo, Y. Detection of fresh-cut produce processing residues on food contact surface materials using hyperspectral imaging. J. Food Measurement and Characterization, 6:48-55. 2012.  
<LI>Yang, C.C., <STRONG>Kim, M.S.</STRONG>, Kang, S., Cho, B., Chao, K., Lefcourt, A.M., and Chan, D. Red to far-red multispectral fluorescence image fusion for detection of fecal contamination on apples. J. of Food Engineering, 108:312-319. 2012. </LI></OL> 
<P style="TEXT-ALIGN: right"><I><A class=toolNav href="#top">go back to the top</A></I> </P> 
<H1><A name=2011></A><FONT color=#006666>2011</FONT> </H1> 
<OL> 
<LI>Chao, K., Qin, J., <STRONG>Kim, M.S.</STRONG>, and Mo, C. 2011. A Raman chemical imaging system for detection of contaminants in food. Proceedings of SPIE Vol. 8027, 10:1-10.  
<LI>Cho, B., <STRONG>Kim, M.S.</STRONG>, Lee, H, and Delwiche, S.R. 2011. Infra-red imaging technology for detection of bruise damages of ‘Shingo’ pear. Proceedings of SPIE Vol. 8027, I:1-7.  
<LI>Delwiche, S.R., <STRONG>Kim, M.S.</STRONG>, and Dong, Y. 2011. Fusarium damage assessment in wheat kernels by Vis/NIR hyperspectral imaging. J. of Sensing and Instrumentation for Food Quality and Safety. Sensing and Instrumentation for Food Quality and Safety. 5:63-71.  
<LI><STRONG>Kim, M.S.</STRONG>, Chao, K., Chan, D.E., Jun, W., Lefcourt, A.M., Delwiche, S.R., and Lee, K. 2011. Line-scan hyperspectral imaging platform for food safety and quality evaluation: System characterization and enhancement. Trans. ASABE. 54(2):703-711.  
<LI><STRONG>Kim, M.S.</STRONG>, Chao, K., Chan, D.E., Yang, C., Lefcourt, A.M., Delwiche, S.R. 2011. Hyperspectral and multispectral imaging technique for food quality and safety inspection. In: Cho, Y., Kang, S. Emerging Technologies for Food Quality and Food Safety Inspection. New York, N.Y.: CRC Press. p. 207-234.  
<LI>Lee, H., <STRONG>Kim, M.S.</STRONG>, Jeong, D., Chao, K., Cho, B, and Delwiche, S. 2011. Hyperspectral Near-infrared Reflectance Imaging for Detection of Defect Tomatoes. Proceedings of SPIE Vol. 8027, J:1-9.  
<LI>Motabar, P., Lefcourt, A.M., Tasch, U., <STRONG>Kim, M.S.</STRONG>, and Rostamian, R. 2011. Use of inertial properties to orient tomatoes. Trans. ASABE. 54(2):517-525.  
<LI>Park, B., Yoon, S., Windham, W., Lawrence, K., <STRONG>Kim, M.S.</STRONG>, and Chao, K. 2011. Line-scan hyperspectral imaging for real-time on-line poultry fecal detection. Sensing and Instrumentation for Food Quality and Safety. 5(1): 25-32.  
<LI>Qin, J., Chao, K., and <STRONG>Kim, M.S.</STRONG> 2011. Development of a Raman chemical imaging system for food safety inspection. Proceedings of SPIE Vol. 8027, 3:1-11.  
<LI>Qin, J., Chao, K., <STRONG>Kim, M.S.</STRONG>, Kang, S., and Jun, W. 2011. Detection of organic residues on poultry processing equipment surfaces by LED-induced fluorescence imaging. Applied Engineering in Agriculture. 27(1):153-161.  
<LI>Tang, X., Mo, C., Chan, D., Peng, Y., Qin, J., Yang, C., <STRONG>Kim, M.S.</STRONG>, Chao, K. 2011. Physical and mechanical properties of spinach for whole-surface online imaging inspection. Proceedings of SPIE Vol. 8027, 11:1-9.  
<LI>Yang, C.C., <STRONG>Kim, M.S.</STRONG>, Chao, K., Kang, S., Lefcourt, A.M. 2011. Fast and accurate image recognition algorithms for fresh produce food safety sensing. Proceedings of SPIE Vol. 8027, G:1-12.  
<LI>Yang, C.C., <STRONG>Kim, M.S.</STRONG>, Kang, S., Cho, B., Chao, K., Lefcourt, A., and Chan, D.E. 2011. Red to far-red multispectral fluorescence image fusion for detection of fecal contamination on apples. J. of Food Engineering, 10.1016/j.jfoodeng.2011.08.008.  
<LI>Yang, C.C., <STRONG>Kim, M.S.</STRONG>, Kang, S., Tao, T., Chao, K., Lefcourt, A., and Chan, D.E. 2011. Development of a simple multispectral algorithm for detection of fecal contamination on apple. Sensing and Instrumentation for Food Quality and Safety. 5(2):10-18. </LI></OL> 
<P style="TEXT-ALIGN: right"><I><A class=toolNav href="#top">go back to the top</A></I> </P> 
<H1><A name=2010></A><STRONG><FONT color=#006666>2010</FONT></STRONG> </H1> 
<OL> 
<LI>Chao, K., Yang, C., and <STRONG>Kim, M.S.</STRONG> 2010. Spectral line-scan imaging system for high-speed nondestructive wholesomeness inspection of broilers. Trends in Food Science & Technology. 21(3):129-137. <A href="http://dx.doi.org/10.1016/j.tifs.2009.08.001">doi:10.1016/j.tifs.2009.08.001</A>  
<LI>Delwiche, S.R. and <STRONG>Kim, M.S.</STRONG>. 2010. Damage and quality assessment in wheat kernels by NIR hyperspectral imaging. Proceedings of SPIE Vol. 7676, 767607.  
<LI>Jun, W., <STRONG>Kim, M.S.</STRONG>, Cho, B., Millner, Chao, K., and Chan, D. 2010. Microbial biofilm detection on food contact surfaces by macro-scale fluorescence imaging, J. of Food Engineering. 99:314-322.  
<LI>Kang, S., Lee, K., Son, J., <STRONG>Kim, M.S.</STRONG>, and Chao, K. 2010. Real-time near-infrared spectroscopic inspection system for adulterated sesame oil. Proceedings of SPIE Vol. 7676, 76760V.  
<LI><STRONG>Kim, M.S.</STRONG>, Chao, K., Chan, D., Yang, C.C., Lefcourt, A.M, Delwiche, S. 2010. Hyperspectral imaging technologies for Nondestructive Agro-food evaluation. Proceeding of International Symposium on Advanced and Innovative Sensing Technology for Agro-food Quality Measurement, pp: 57-71.  
<LI><STRONG>Kim, M.S.</STRONG>, Chen, Y., Chao, K., and Lefcourt, A. 2010. Simultaneous acquisition of fluorescence and reflectance imaging techniques with a single imaging device for multitask inspection. US Patent # 7,787,111, USPTO. Aug. 31, 2010.  
<LI>Kim, T., Cho, B., and <STRONG>Kim, M.S.</STRONG> 2010. Emission filter design to detect poultry skin tomors using fluorescence hyperspectral imaging. Colombian J. Animal Science. 23:9-16.  
<LI>Park, B., Yoon, S., Windham, W.R., Lawrence, K.C., <STRONG>Kim, M.S.</STRONG>, and Chao, K. 2010. Line-scan hyperspectral imaging for real-time poultry fecal detection. Proceedings of SPIE Vol. 7676, 76760I.  
<LI>Qin, J., Chao, K., and <STRONG>Kim, M.S.</STRONG> 2010. Development of a Raman chemical imaging system for food safety inspection. ASABE Paper number: 1009166.  
<LI>Qin, J., Chao, K., and <STRONG>Kim, M.S.</STRONG> 2010. Raman chemical imaging system for food safety and quality inspection. Trans. ASABE. 53(6):1873-1882.  
<LI>Qin, J., Jun, W., <STRONG>Kim, M.S.</STRONG>, and Chao, K. 2010. Detection of organic residues on food processing equipment surfaces by spectral imaging method Proceedings of SPIE Vol. 7676, 767608.  
<LI>Yang, C.C., Chao, K., <STRONG>Kim, M.S.</STRONG>, and Chan, D., Machine vision system for online wholesomeness inspection of poultry carcasses, Poultry Science. 89(6): 1252–1264. 2010.  
<LI><A href="/SP2UserFiles/person/3003/2010YangEtAl7676spie2010.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Yang, C.C., Jun, W., <STRONG>Kim, M.S.</STRONG>, Chao, K., Kang, S., Chan, D., and Lefcourt, A. 2010. Classification of fecal contamination on leafy greens by hyperspectral imaging. Proceedings of SPIE. 7676:76760F.</LI></OL> 
<P style="TEXT-ALIGN: right"><I><A class=toolNav href="#top">go back to the top</A></I> </P> 
<H1><A name=2009></A><STRONG><FONT color=#006666>2009</FONT></STRONG> </H1> 
<OL> 
<LI>Bae, H.H., <STRONG>Kim, M.S.</STRONG>, Sicher, R., Kim, S.H., Strem, M., Bailey, B., and Melnick, R. 2009. The Beneficial endophyte, Trichoderma hamatum, isolate DIS 219B promotes growth and delays the onset of drought stress responses in Theobroma cacao. J. Exp. Botany. 60:3279-3295.  
<LI>Chao, K., Yang, C. C., and <STRONG>Kim, M.S.</STRONG> 2009. Line-scan spectral imaging system for online poultry carcass inspection. J. Food Processing Eng. 34(1):125-143.  
<LI>Cho, B. and <STRONG>Kim, M.S.</STRONG> 2009. Multispectral imaging technology for detecting bruising damages of apple and pear. Proceedings of the 6th International Joint Symposium between Korea and Japan. Food Supply, Marketing, Quality and Safety Workshop. Kyushu, Japan.  
<LI>Cho, B., <STRONG>Kim, M.S.</STRONG>, Chao, K., Lawrence, K., Park, B, and Kim, K. 2009. Detection of fecal residue on poultry carcasses by laser induced fluorescence imaging. J. Food Science. 74(3): 154-159.  
<LI>Delwiche, S., Yang, I., and <STRONG>Kim, M.S.</STRONG>&nbsp;2009. Hyperspectral imaging for detection of black tip damage in wheat kernels. Proceedings of SPIE. 7315:73150K-1-6. 2009.  
<LI>Jun, W., <STRONG>Kim, M.S.</STRONG>, Chao, K., and Lefcourt, A.M. 2009. Detection of microbial biofilms on food processing surfaces: Hyperspectral fluorescence imaging study. Proceedings of SPIE. 7315:73150S-1-8.  
<LI><IMG alt="For article reprints, please contact the journal or the author(s)" src="/images/docs/18159_18353/PDF_gray.jpg">&nbsp;Jun, W., <STRONG>Kim, M.S.</STRONG>, Lee, K., Millner, P., and Chao, K. 2009. Assessment of bacterial biofilm on stainless steel by hyperspectral fluorescence imaging. Sensing and Instrumentation for Food Quality and Safety. 3(1):41-48. <A href="http://dx.doi.org/10.1007/s11694-009-9069-1">doi:10.1007/s11694-009-9069-1</A>  
<LI><STRONG>Kim, M.S.</STRONG>, Chao, K., Chan D.E., Jun, W., Lee, K., Kang, S., Yang, C.C., and Lefcourt, A.M. 2009. Nondestructive sensing technologies for food safety, International symposium for Improvement of Agro-Food Safety, Proceedings. pp:119-126.  
<LI><STRONG>Kim, M.S.</STRONG>, Chao, K., Chan, D., and Lefcourt, A.M. 2009. Line-scan imaging for improved high-speed food safety inspection. SPIE News Room Article, 10.1117/2.1200903.1564.  
<LI>Kim, T., Cho, B., and <STRONG>Kim, M.S.</STRONG> 2009. OPtimal filter design for fluorescence emission to detect poultry skin tumor. ASABE paper 090049.  
<LI>Lefcourt, A.M., <STRONG>Kim, M.S.</STRONG>, Chen, Y.R. Use of Nanosecond Scale, Time-Resolved, Imaging to Differentiate Contemporaneous Fluorescence Responses For Multiple Substances. US Patent, 7,547,508. June 16, 2009.  
<LI>Lefcourt, A.M., Narayanan, P., Tasch, U., <STRONG>Kim, M.S.</STRONG>, Reese, D., Rostamian, R., and Lo, Y.M. 2009. Orienting apples for imaging using their inertial properties and random apple loading. Biosystems Engineering. 104(1):64-71. <A href="http://dx.doi.org/10.1016/j.biosystemseng.2009.06.002">doi:10.1016/j.biosystemseng.2009.06.002</A>  
<LI><A href="/SP2UserFiles/person/3003/2009LiuEtAl63-4ApplSpectroscopy477-480.pdf"><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Liu, Y., Chao, K., <STRONG>Kim, M.S.</STRONG>, Tuschel, D., Oklhovyk, O., Priore, R.J. 2009. Potential of Raman spectroscopy and imaging methods for rapid and routine screening of the presence of melamine in animal feed and foods. Applied Spectroscopy. 63(4):477-480.  
<LI>Priore, R., Tuschel, D., Olkhovyk, O., Drauch, A., Treado, P., <STRONG>Kim, M.S.</STRONG>, and Chao, K. 2009. Recent advances in chemical imaging technology for the detection of contaminants for food safety and security. Proceedings of SPIE. 7315: 731507-1-8.  
<LI>Reese, D., Lefcourt, A.M., <STRONG>Kim, M.S.</STRONG>, and Lo, M. 2009. Using parabolic mirrors to image 100% of the surface of apples. Bioresource Technology. 100:4499-4506.  
<LI><IMG alt="For article reprints, please contact the journal or author(s)" src="/sp2userfiles/place/12655300/graphics/PDF_gray.jpg">&nbsp;Yang, C.-C., Chao, K., and <STRONG>Kim, M.S.</STRONG>&nbsp; 2009. Machine vision system for online inspection of freshly slaughtered chickens. Sensing and Instrumentation for Food Quality and Safety. 3(1):70-80.  
<LI>Yang, C.C., Chao, K., and <STRONG>Kim, M.S.</STRONG>&nbsp;2009. Automatic inspection using machine vision for food safety. Proceedings of the 7th Congress of Computers in Agriculture and Natural Resources. <A href="http://dx.doi.org/10.1007/s11694-008-9067-8">doi:10.1007/s11694-008-9067-8</A>  
<LI>Yang, I.C., Delwiche, S.R., Chen, S., <STRONG>Kim, M.S.</STRONG>, Tsai, C.Y., and Lo, Y.M. 2009. Determination of wheat kernel black point damage using hyperspectral imaging. J. of Agricultural Machinery. 18(3):29-44. </LI></OL> 
<P style="TEXT-ALIGN: right"><I><A class=toolNav href="#top">go back to the top</A></I> </P> 
<H1><A name=2008></A><STRONG><FONT color=#006666>2008</FONT></STRONG> </H1> 
<OL> 
<LI><A href="/SP2UserFiles/person/3003/2008Bae46PPB174-188.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Bae, H., Kim, S.H., <STRONG>Kim, M.S.</STRONG>, Sicher, R.C., Strem, M.D., Natarajan, S., and Bailey, B.A. 2008. The drought response of Theobroma cacao (cacao) and the regulation of genes involved in polyamine biosynthesis by drought and other stresses. Plant Physiology and Biochemistry. 46:174-188.  
<LI>Chao, K., <STRONG>Kim, M.S.</STRONG>, and Lawrence, K.C. 2008. Optical methods for food inspection. Sensing and Instrumentation for Food Quality and Safety. 2(2): 73-74.  
<LI><A href="/SP2UserFiles/person/3003/2008ChaoEtAl24_1ApplEngrAgr49-55.pdf"><IMG border=0 alt="Click here to view or download a PDF file for this document" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Chao, K., Nou, X., Liu, Y., <STRONG>Kim, M.S.</STRONG>, Chan, D.E., Yang, C., Patel, J.R., Sharma, M. 2008. Detection of fecal/ingesta contaminants on poultry processing equipment surfaces by visible and near-infrared reflectance spectroscopy. Applied Engineering in Agriculture. 24(11):49-55.  
<LI>Chao, K., Yang, C., and <STRONG>Kim, M.S.</STRONG>2008. Line-scan spectral imaging system for online poultry carcass inspection. Journal of Food Process Engineering. (accepted 08/28/2008)  
<LI><A href="/SP2UserFiles/person/3003/2008ChaoEtAl24_4ApplEngrAgr475-485.pdf"><IMG border=0 alt="Click here to view or download a PDF file for this document" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Chao, K., Yang, C., <STRONG>Kim, M.S.</STRONG>, and Chan, D.E. 2008. High throughput spectral imaging system for wholesomeness inspection of chicken. Applied Engineering in Agriculture 24(4): 475-485.  
<LI><STRPNG>Kim, M.S.</STRONG>, Chen, Y.-R., Cho, B., Lefcourt, A.M., Chao, K. and Yang, C.-C. 2008. Online hyperspectral line-scan fluorescence imaging for safety inspection of apples. Acta Horticulturae. 768(1):385-390.  
<LI><STRONG>Kim, M.S.</STRONG>, Cho, B., Lefcourt, A.M., Chen, Y.R., and Kang, S. 2008. Multispectral fluorescence lifetime imaging of animal feces contaminated apples by time-resolved laser-induced fluorescence imaging system with tunable excitation wavelengths. Applied Optics. 47:1608-1616  
<LI><STRONG>Kim, M.S.</STRONG>, Lee, K., Chao, K., Cho, B., Lefcourt, A.M., Jun, W., and Chan, D. 2008. Online multitasking imaging for safety and quality inspection of apples. Modern Physics Letter B. In press. (Accepted Mar. 5, 2008)  
<LI><STRONG>Kim, M.S.</STRONG>, Lee, K., Chao, K., Lefcourt, A.M, Jun, W., Chan, D.E. 2008. Multispectral line-scan imaging system for simultaneous fluorescence and reflectance measurements of apples: multitask apple inspection system. Sensing and Instrumentation for Food Quality and Safety. 2(2):123-129.  
<LI>Lee, K., Kang, S., Delwiche, S.R., Kim, <STRONG>M.S.</STRONG>, and Noh, S. 2008. Correlation analysis of hyperspectral imagery for multispectral wavelength selection for detection of defects on apples. Sensing and Instrumentation for Food Quality and Safety. 2(2): 90-96.  
<LI><A href="/SP2UserFiles/person/3003/2008LefcourtEtAl24_1ApplEngrAgr123-129.pdf"><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Lefcourt, A.M, Narayanan, P., Tasch, U., Rostamian, R., <STRONG>Kim, M.S.</STRONG>, and Chen, Y.R. 2008. Technical note: Algorithms for parameterization of dynamics of inertia-based apple orientation. Applied Engineering in Agriculture. 24(1):123-129.  
<LI>Narayanan, P., Lefcourt, A.M., <STRONG>Kim, M.S. </STRONG>, Tasch, U., Rostamian, R., and Grinblat, A. 2008. Development of technology for orienting apples for automated on-line inspection. Transactions of ASABE. (accepted 07/15/2008)  
<LI><A href="/SP2UserFiles/person/3003/2008NarayananEtAl51_4TransASABE1353-1364.pdf"><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Narayanan, P., Lefcourt, A.M., Tasch, U., Rostamian, R., Grinblat, A., and <STRONG>Kim, M.S. </STRONG>2008. Theoretical analysis of stability of axially symmetric rotating objects with regard to orienting apples. Transactions of the ASABE 51(4):1353-1364.  
<LI>Liu, Y., Chao, K., <STRONG>Kim, M.S.</STRONG>, and Nou, X. 2008. Rapid screening and species identification of <I>E. Coli</I>, <I>Listeria</I>, and <I>Salmonella</I>by SERS technique. In: Proceedings of SPIE, Volume 6983. SPIE Defense and Security 2008: Special Session on Food Safety, Visual Analytics, Resource Restricted Embedded and Sensor Networks, and 3D Imaging and Display. 698309.  
<LI><A href="/SP2UserFiles/person/3003/2008LiuEtAl23_2Spectroscopy48-54.pdf"><IMG border=0 alt="Click here to view or download a PDF file for this document" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Liu, Y., Chen, Y.R., Nou, X., <STRONG>Kim, M.S.</STRONG>, and Chao, K. 2008. Label-free SERS for rapid species identification of <I>Escherichia Coli</I>, <I>Listeria Monocytogenes</I>, and <I>Salmonella Typhimurium</I>bacteria. Spectroscopy. 23(2):48-54.  
<LI>Qin, J., Burks, T., <STRONG>Kim, M.S.</STRONG>, Chao, K., Ritenour, M.A. 2008. Citrus canker detection using hyperspectral reflectance imaging and PCA-based image classification method. Sensing and Instrumentation for Food Quality and Safety. 2(3): 168-177. </LI></OL> 
<P style="TEXT-ALIGN: right"><I><A class=toolNav href="#top">go back to the top</A></I> </P> 
<H1><A name=2007></A><STRONG><FONT color=#006666>2007</FONT></STRONG> </H1> 
<OL> 
<LI><A href="/SP2UserFiles/person/3003/2007Chao1SensInstrFoodQualSafety62-71.pdf" target=_blank><IMG border=0 alt="Click here to view or download a PDF file for this document" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Chao, K., Yang, C.C., Chen, Y.R., <STRONG>Kim, M.S.</STRONG>, and Chan, D.E. 2007. Fast line-scan imaging system for broiler carcass inspection. Sensing and Instrumentation for Food Quality and Safety. 1:62-71.  
<LI>Chao, K., Yang, C.-C., Chen, Y.-R., <STRONG>Kim, M.S.</STRONG>, and Chan, D.E. 2007. Hyperspectral-multispectral line-scan imaging system for automated poultry carcass inspection applications for food safety. Poultry Science. 86(11):2450-2460.  
<LI><A href="/SP2UserFiles/person/3003/2007Cho57-2CompElecAgr177-189.pdf"><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Cho, B., Chen, Y.R., and <STRONG>Kim, M.S</STRONG>. 2007. Multispectral detection of organic residues on poultry processing plant equipment based on hyperspectral reflectance imaging technique. Computers and Electronics in Agriculture. 57(2):177-189.  
<LI>Cho, B. and <STRONG>Kim, M.S</STRONG>. 2007. Study on optimal fluorescence excitation and emission bands for poultry surface inspection. KSAM 12(2):438-441.  
<LI>Hunt, E.R., Daughtry, C.S.T., <STRONG>Kim, M.S.</STRONG>, and Parker Williams, A. 2007. Combining canopy reflectance models and spectral angle mapper to detect invasive weeds by remote sensing, Journal of Applied Remote Sensing. 1:1-17.  
<LI><A href="/SP2UserFiles/person/3003/2007Kim1-3SensInstrumFoodQualSafety151-159.pdf"><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;<STRONG>Kim, M.S.</STRONG>, Chen, Y.R., Cho, B.K., Chao, K., Yang, C., Lefcourt, A.M., and Chan, D. 2007. Hyperspectral reflectance and fluorescence line-scan imaging for online defect and fecal contamination inspection of apples. Sensing and Instrumentation for Food Quality and Safety. 1(3):151-159.  
<LI><A href="/SP2UserFiles/person/3003/2007Liu81JFoodEngr412-418.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Liu, Y., Chen, Y.R., <STRONG>Kim, M.S.</STRONG>, Chan, D.E., and Lefcourt, A.M. 2007. Development of simple algorithms for the detection of fecal contaminants on apples from visible/near infrared hyperspectral reflectance imaging. Journal of Food Engineering. 81:412-418.  
<LI>Narayanan, P., Lefcourt, A.M., Tasch, U., Rostamian, R., and <STRONG>Kim, M.S</STRONG>. 2007. Tests of the ability to orient apples using their inertial properties. American Society of Agricultural and Biological Engineers. ASABE Paper No. 07-6246.  
<LI>Xu, C., Kim, I., and <STRONG>Kim, M.S</STRONG>. 2007. Poultry skin tumor detection in hyperspectral reflectance images by combining classifiers. Lecture Notes in Comp. Sci. 4633: 1289-1296. </LI></OL> 
<P style="TEXT-ALIGN: right"><I><A class=toolNav href="#top">go back to the top</A></I> </P> 
<H1><A name=2006></A><STRONG><FONT color=#006666>2006</FONT></STRONG> </H1> 
<OL> 
<LI>Bae, H., <STRONG>Kim, M.S.</STRONG>, Sicher, R.C., Bae, H.J., and Bailey, B.A. 2006. Necrosis- and ethylene-inducing peptide (Nep1) from Fusarium oxysporum induces a complex cascade of transcripts associated with signal transduction and program cell death. Plant Physiology. 141:1056-1067.  
<LI>Chao, K., Yang, C.C., Chen, Y.R., Chan, D.E., and <STRONG>Kim, M.S</STRONG>. 2006. Poultry carcass inspection by a fast line-scan imaging system: results from in-plant testing. In: Chen, Y.R., Meyer, G.E., and Tu, S.I., editors. Proceedings of SPIE, Volume 6381. Optics for Natural Resources, Agriculture, and Foods, October 3, 2006, Boston, Massachusetts. 6381:63810V.  
<LI>Cho, B., and <STRONG>Kim, M.S</STRONG>. 2006. Multispectral reflectance imaging for detection of organic residues on poultry processing plant equipment. KSAM 11(2):372-375.  
<LI><A href="/SP2UserFiles/person/3003/2006Ding45-15ApplOpt3516-3526.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Ding, F., Chen, Y.R., Chao, K., and <STRONG>Kim, M.S</STRONG>. 2006. Three-color mixing for classifying agricultural products for safety and quality. Applied Optics. 45(15):3516-3526.  
<LI><A href="/SP2UserFiles/person/3003/2006Kim60-10ApplSpec1212-1216.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;<STRONG>Kim, M.S.</STRONG>, Chen, Y.R., Kang, S., Kim, I., Lefcourt, A.M., and Kim, M. 2006. Fluorescence characteristics of wholesome and unwholesome chicken carcasses. Applied Spectroscopy. 60(10):1210-1216.  
<LI><STRONG>Kim, M.S.</STRONG>, Cho, B.K., Yang, C.C., Chao, K., Lefcourt, A.M., and Chen, Y.R. 2006. Hyperspectral reflectance and fluorescence line-scan imaging system for online detection of fecal contamination on apples. In: Chen, Y.R., Meyer, G.E., and Tu, S.I., editors. Proceedings of SPIE, Volume 6381. Optics for Natural Resources, Agriculture, and Foods, October 3, 2006, Boston, Massachusetts. 6381:63810P.  
<LI><STRONG>Kim, M.S.</STRONG>, Cho, B., Chao, K., Lefcourt, A.M., Liu, Y., and Chen, Y.R. 2006. Detection of contaminants on poultry processing plant equipment using laser-induced fluorescence imaging. Key Engineering Materials. 321-323:1157-1162.  
<LI>Kim, I., Xu, C., and <STRONG>Kim, M.S</STRONG>. 2006. Poultry skin tumor detection in hyperspectral images using radial basis probabilistic neural network. Lecture Notes in Comp. Sci., 3973:770-776.  
<LI>Lefcourt, A.M., Narayanan, P., Tasch, Y., Rostamian, R., <STRONG>Kim, M.S.</STRONG>, and Chen, Y.R.. 2006. Development of video technology to analyze dynamics of inertia-based apple orientation. In: Chen, Y.R., Meyer, G.E., and Tu, S.I., editors. Proceedings of SPIE, Volume 6381. Optics for Natural Resources, Agriculture, and Foods, October 3, 2006, Boston, Massachusetts. 6381:63810Q.  
<LI>Lefcourt, A.M., <STRONG>Kim, M.S.</STRONG>, Chen, Y.R., and Kang, S. 2006. Systematic approach for using hyperspectral data to develop multispectral imaging systems: Detection of feces on apples, Computers and Electronics in Agriculture. 54:22-35.  
<LI>Lefcourt, A.M. and <STRONG>Kim, M.S</STRONG>. 2006.Technique for normalizing intensity histograms of images when the approximate size of the target is known: Detection of feces on apples using fluorescence imaging. Computers and Electrocnis in Agriculture. 50:135-147.  
<LI><A href="/SP2UserFiles/person/3003/2006Liu14-5JNIRS325-331.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Liu, Y., Chao, K., Chen, Y.R., <STRONG>Kim, M.S.</STRONG>, Nou, X., Chan, D.E., and Yang, C.C. 2006. Comparison of visible and near infrared reflectance spectroscopy for the detection of faeces/ingesta contaminants for sanitation verification at slaughter plants. Journal of Near Infrared Spectroscopy. 14(5):325-331.  
<LI>Liu, Y., Chao, K., Chen, Y.R., <STRONG>Kim, M.S.</STRONG>, Nou, X., Chan, D.E., and Yang, C.C. 2006. Detection of fecal/ingesta contaminants at slaughter plants from a number of characteristic visible and near-infrared bands. In: Chen, Y.R., Meyer, G.E., and Tu, S.I., editors. Proceedings of SPIE, Volume 6381. Optics for Natural Resources, Agriculture, and Foods, October 3, 2006, Boston, Massachusetts. 6381:63810U.  
<LI><A href="/SP2UserFiles/person/3003/2006Liu22-1ApplEngrAgr101-111.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Liu, Y., Chen, Y.R., Wang, C.Y., Chan, D.E., and <STRONG>Kim, M.S</STRONG>. 2006. Development of hyperspectral imaging technique for the detection of chilling injury in cucumbers; spectral and image analysis. Applied Engineering in Agriculture. 22(1):101-111.  
<LI>Narayanan, P., Lefcourt, A.M., Tasch, U., Rostamian, R., Grinblat, A., and <STRONG>Kim, M.S</STRONG>. 2006. Theoretical properties of orienting fruit using stability properties during rotation. American Society of Agricultural and Biological Engineers. ASABE Paper No. 06-1144.  
<LI>Yang, C.C., Chan, D.E., Chao, K., Chen, Y.R., and <STRONG>Kim, M.S</STRONG>. 2006. Development of online line-scan imaging system for chicken inspection and differentiation. In: Chen, Y.R., Meyer, G.E., and Tu, S.I., editors. Proceedings of SPIE, Volume 6381. Optics for Natural Resources, Agriculture, and Foods, October 3, 2006, Boston, Massachusetts. 6381:63810Y.  
<LI><A href="/SP2UserFiles/person/3003/2006Yang95-4BiosystEngr483-496.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Yang, C.C., Chao, K., Chen, Y.R., <STRONG>Kim, M.S.</STRONG>, and Chan, D.E. 2006. Development of fuzzy logic based differentiation algorithm and fast line-scan imaging system for chicken inspection. Biosystems Engineering. 95(4):483-496.  
<LI><A href="/SP2UserFiles/person/3003/2006Yang49-1TransASABE245-257.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Yang, C.C., Chao, K., Chen, Y.R., <STRONG>Kim, M.S.</STRONG>, and Early, H.L. 2006. Simple multispectral image analysis for systemically diseased chicken identification. Transactions of the ASABE. 49(1):245-257. </LI></OL> 
<P style="TEXT-ALIGN: right"><I><A class=toolNav href="#top">go back to the top</A></I> </P> 
<H1><A name=2005></A></STRONG><FONT color=#006666>2005</FONT></STRONG> </H1> 
<OL> 
<LI>Cho, B., <STRONG>Kim, M.S.</STRONG>, and Chen, Y.R. 2005. Hyperspectral imaging technique for detection of poultry fecal residues on food processing equipments. In: Chen, Y.R., Meyer, G.E., Tu, S.I., editors. Proceedings of SPIE, Volume 5996. Optical Sensors and Sensing Systems for Natural Resources and Food Safety and Quality, October 23, 2005, Boston, Massachusetts. 5996:L1-L10.  
<LI><A href="/SP2UserFiles/person/3003/2005Kim682ActaHort1379-1385.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;<STRONG>Kim, M.S.</STRONG>, Lefcourt, A.M., and Chen, Y.R. 2005. Multispectral laser induced fluorescence imaging techniques for nondestructive assessment of postharvest food quality and safety. Proc. 5th International Postharvest Symposium, eds. F. Mencarelli and P. Tonutti. Acta Hort. 682: 1379-1386.  
<LI><A href="/SP2UserFiles/person/3003/2005Kim71-1JFoodEngr85-91.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;<STRONG>Kim, M.S.</STRONG>, Lefcourt, A.M., Chen, Y.R., and Tao, Y. 2005. Automated detection of fecal contamination of apples based on multispectral fluorescence image fusion. Journal of Food Engineering. 71(1):85-91.  
<LI>Lee, K., Kang, S., <STRONG>Kim, M.S.</STRONG>, and Noh, S. 2005. Hyperspectral imaging for detecting defect on apples. American Society of Agricultural Engineers. ASAE Paper No. 05-3075.  
<LI><A href="/SP2UserFiles/person/3003/2005Lefcourt44-7ApplOpt1160-1170.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Lefcourt, A.M., <STRONG>Kim, M.S.</STRONG>, and Chen, Y.R. 2005. Detection of fecal contamination on apples with nanosecond-scaled time-resolved imaging of laser-induced fluorescence. Applied Optics. 44(7):1160-1170.  
<LI><A href="/SP2UserFiles/person/3003/2005Lefcourt48-1CompElecAgr63-74.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Lefcourt, A.M., <STRONG>Kim, M.S.</STRONG>, and Chen, Y.R. 2005. A transportable fluorescence imaging system for detecting fecal contaminants. Computers and Electronics in Agriculture. 48(1):63-74.  
<LI><A href="/SP2UserFiles/person/3003/2005Lefcourt48-4TransASAE1587-1593.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Lefcourt, A.M., <STRONG>Kim, M.S.</STRONG>, and Chen, Y.R. 2005. Detection of fecal contamination in apple calyx by multispectral laser-induced fluorescence. Transactions of the ASAE. 48(4):1587-1593.  
<LI>Liu, Y., Chen, Y.R., Wang, C.-Y., Chan, D.E., and <STRONG>Kim, M.S.</STRONG>2005. Development of simple algorithm for the detection of chilling injury in cucumbers from visible/near-infrared hyperspectral imaging. Applied Spectroscopy. 59(1):78-85  
<LI><A href="/SP2UserFiles/person/3003/2005Middleton81PhotochemPhotobio1075-1085.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Middleton, E.M., <STRONG>Kim, M.S.</STRONG>, Krizek, D.T., and Bajwa, R.K.S. 2005. Evaluating UV-B effects and EDU protection in soybean leaves using fluorescence. Photochemistry and Photobiology. 81:1075-1085.  
<LI><A href="/SP2UserFiles/person/3003/2005Vargas70-8JFoodSciE471-E476.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Vargas, A.M., <STRONG>Kim, M.S.</STRONG>, Tao, Y., Lefcourt, A.M., Chen, Y.R., Luo, Y., Song, Y., and Buchanan, R. 2005. Detection of fecal contamination on cantaloupes using hyperspectral fluorescence imagery. Journal of Food Science. 70(8):E471-E476.  
<LI>Yang, C.C., Chao, K., Chen, Y.R., and <STRONG>Kim, M.S</STRONG>. 2005. Development of fast line scanning imaging algorithm for diseased chicken detection. In: In: Chen, Y.R., Meyer, G.E., Tu, S.I., editors. Proceedings of SPIE, Volume 5996. Optical Sensors and Sensing Systems for Natural Resources and Food Safety and Quality, October 23, 2005, Boston, Massachusetts. 5996:C1-C12. </LI></OL> 
<P style="TEXT-ALIGN: right"><I><A class=toolNav href="#top">go back to the top</A></I> </P> 
<H1><A name=2004></A><STRONG><FONT color=#006666>2004</FONT></STRONG> </H1> 
<OL> 
<LI><A href="/SP2UserFiles/person/3003/2004Cheng47-4TransASAE1313-1320.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Cheng, X., Chen, Y.R., Tao, Y., Wang, C.Y., <STRONG>Kim, M.S.</STRONG>, and Lefcourt, A.M. 2004. A novel integrated PCA and FLD method on hyperspectral image feature extraction for cucumber chilling damage inspection. Transactions of the ASAE. 47(4):1313-1320.  
<LI>Kang, S., <STRONG>Kim, M.S.</STRONG>, and Kim, I. 2004. Chicken disease characterization by fluorescence spectroscopy, Journal of Agricultural and Biosystems Engineering. 5(1):25-29.  
<LI><A href="/SP2UserFiles/person/3003/2004KimI47-5TransASAE1785-1792.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Kim, I., <STRONG>Kim, M.S.</STRONG>, Chen, Y.R., and Kong, S.G. 2004. Detection of skin tumors on chicken carcasses using hyperspectral fluorescence imaging. Transactions of the ASAE. 47(5):1785-1792.  
<LI><STRONG>Kim, M.S.</STRONG>, Lefcourt, A.M., Chen, Y.R., and Kang, S. 2004. Uses of hyperspectral and multispectral laser induced fluorescence imaging techniques for food safety inspection. Key Engineering Materials. 270-273:1055-1063.  
<LI><STRONG>Kim, M.S.</STRONG>, Lefcourt, A.M., Chen, Y.R. 2004. Ns-scale time-resolved laser induced fluorescence imaging for detection of fecal contamination on apples. In: Chen, Y.R., Tu, S.I., editors. Proceedings of SPIE, Volume 5587. Nondestructive Sensing for Food Safety, Quality, and Natural Resources. October 26, 2004, Philadelphia, Pennsylvania. 5587:190-197.  
<LI><A href="/SP2UserFiles/person/3003/2004Kong43-4ApplOpt824-833.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Kong, S.G., Chen, Y.R., Kim, I., and <STRONG>Kim, M.S</STRONG>. 2004. Analysis of hyperspectral fluorescence images for poultry skin tumor inspection. Applied Optics. 43(4):824-833.  
<LI>Liu, Y., Chen, Y.R., Wang, C.Y., Chan, D.E., and <STRONG>Kim, M.S</STRONG>. 2004. Development of hyperspectral imaging technique for the detection of chilling injury in cucumbers. In: Chen, Y.R., Tu, S.I., editors. Proceedings of SPIE, Volume 5587. Nondestructive Sensing for Food Safety, Quality, and Natural Resources. October 26, 2004, Philadelphia, Pennsylvania. 5587:18-28.  
<LI><A href="/SP2UserFiles/person/3003/2004Mehl61-1JFoodEngr67-81.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Mehl, P.M., Chen, Y.R., <STRONG>Kim, M.S.</STRONG>, and Chan, D.E. 2004. Development of hyperspectral imaging technique for the detection of apple surface defects and contaminations. Journal of Food Engineering. 61(1):67-81.  
<LI>Vargas, A.M., <STRONG>Kim, M.S.</STRONG>, Tao, Y., Lefcourt, A.M., and Chen, Y.R. 2004. Safety inspection of cantaloupes and strawberries using multispectral imaging techniques. American Society of Agricultural Engineers. ASAE Paper No. 04-3056.  
<LI>Yang, C.C., K. Chao, Chen, Y.R., and <STRONG>Kim, M.S</STRONG>. 2004. Application of multispectral imaging for identification of systemically diseased chicken. American Society of Agricultural Engineers, ASAE Paper No. 04-3056. </LI></OL> 
<P style="TEXT-ALIGN: right"><I><A class=toolNav href="#top">go back to the top</A></I> </P> 
<H1><A name=2003></A><STRONG><FONT color=#006666>2003</FONT></STRONG> </H1> 
<OL> 
<LI>Chen, Y.R., and <STRONG>Kim, M.S</STRONG>. Visible/NIR imaging spectroscopy for assessing quality and safety of agro-foods. 11th International Conference on Near Infrared Spectroscopy, NIR2003 Proceedings.  
<LI><STRONG>Kim, M.S.</STRONG>, Lefcourt, A.M., and Chen, Y.R. 2003. Multispectral fluorescence imaging techniques for nondestructive food safety inspection. In: Bennedsen, B.S., Chen, Y.R., Meyer, G.E., Senecal, A.G., Tu, S.I., editors. Proceedings of SPIE, Volume 5271. Monitoring Food Safety, Agriculture, and Plant Health, October 29, 2003, Providence, Rhode Island. 5271:62-72.  
<LI><STRONG>Kim, M.S.</STRONG>, Lefcourt, A.M., and Chen, Y.R. 2003. Multispectral laser-induced fluorescence imaging system for large biological samples. Applied Optics. 42(19):3927-2934.  
<LI><STRONG>Kim, M.S.</STRONG>, Lefcourt, A.M., and Chen, Y.R. 2003. Optimal fluorescence excitation and emission bands for detection of fecal contamination. Journal of Food Protection. 66(7):1198-1207.  
<LI><STRONG>Kim, M.S.</STRONG>, Mulchi, C.L., Daughtry, C.S.T. and McMurtrey, J.E. 2003. Assessment of combined effects of elevated tropospheric O3 and CO2 on soybean under well-watered and restricted soil moisture conditions by multispectral fluorescence imaging techniques. ASA Special Publication, 66:223-253.  
<LI><A href="/SP2UserFiles/person/3003/2003Lefcourt42-19ApplOpt3935-3943.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Lefcourt, A.M., <STRONG>Kim, M.S.</STRONG>, and Chen, Y.R. 2003. Automated detection of fecal contamination of apples by multispectral laser-induced fluorescence imaging. Applied Optics. 42(19):3935-3943.  
<LI>Lefcourt, A.M., <STRONG>Kim, M.S.</STRONG>, and Chen, Y.R. 2003. Portable multispectral fluorescence imaging system for food safety applications. In: Bennedsen, B.S., Chen, Y.R., Meyer, G.E., Senecal, A.G., Tu, S.I., editors. Proceedings of SPIE, Volume 5271. Monitoring Food Safety, Agriculture, and Plant Health, October 29, 2003, Providence, Rhode Island. 5271:73-84. </LI></OL> 
<P style="TEXT-ALIGN: right"><I><A class=toolNav href="#top">go back to the top</A></I> </P> 
<H1><A name=2002></A><STRONG><FONT color=#006666>2002</FONT></STRONG> </H1> 
<OL> 
<LI>Campbell, P.E., Middleton, E., Corp, L.A., McMurtrey, J.E., <STRONG>Kim, M.S.</STRONG>, Chappelle, E.W., and Butcher, L.M. 2002. Contribution of chlorophyll fluorescence to the reflectance of corn foliage. Proceedings of the International Geoscience and Remote Sensing Symp., IGARSS 2002, Toronto, Canada. (CD)  
<LI><A href="/SP2UserFiles/person/3003/2002Chen36CompElecAgr173-191.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Chen, Y.R., Chao, K, and <STRONG>Kim, M.S</STRONG>. 2002. Future trends of machine vision technology for agricultural applications. Computers and Electronics in Agriculture. 36(2-3): 173-191.  
<LI>Corp, L.A., Middleton, E.M., McMurtrey, J.E., Campbell, P.K.E., <STRONG>Kim, M.S.</STRONG>, Chappelle, E.W., and Butcher, L.M. 2002. Fluorescence imaging techniques for monitoring vegetation, Proceedings, International Geoscience and Remote Sensing Symp., IGARSS 2002, Toronto, Canada, CD.  
<LI><A href="/SP2UserFiles/person/3003/2002Kang023061ASAEpaper.pdf"><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Kang, S., <STRONG>Kim, M.S.</STRONG>, Chao, K., Kim, I., and Chen, Y.R. 2002. Chicken disease characterization by fluorescence spectroscopy. American Society of Agricultural Engineers. ASAE Paper No. 02-3061.  
<LI><A href="/SP2UserFiles/person/3003/2002Kim45-6TransASAE2027-2037.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;<STRONG>Kim, M.S.</STRONG>, Lefcourt, A.M., Chao, K., Chen, Y.R., Kim, I., and Chan, D.E. 2002. Multispectral detection of fecal contamination on apples based on hyperspectral imagery: Part I. Application of visible and near-infrared reflectance imaging. Transactions of the ASAE. 45(6):2027-2037.  
<LI><STRONG>Kim, M.S.</STRONG>, Lefcourt, A.M., and Chen, Y.R. 2002. Multispectral laser induced fluorescence imaging system for detection of fecal contamination on agricultural commodities. American Society of Agricultural Engineers. ASAE Paper No. 02-3141.  
<LI><A href="/SP2UserFiles/person/3003/2002Kim45-6TransASAE2039-2047.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;<STRONG>Kim, M.S.</STRONG>, Lefcourt, A.M., Chen, Y.R., Kim, I., Chan, D.E., and Chao, K. 2002. Multispectral detection of fecal contamination on apples based on hyperspectral imagery: Part II. Application of hyperspectral fluorescence imaging. Transactions of the ASAE. 45(6):2039-2047.  
<LI><STRONG>Kim, M.S.</STRONG>, Mulchi, C.L., McMurtrey, J.E., Daughtry, C.S.T., and Chappelle, E.W. 2002. Chapter 17: Assessment of environmental plant stresses using multispectral steady-state fluorescence imagery. In: Omasa, K., Saji, H., Youssefan, S., Kondo, N., editors. Air Pollution and Plant Biotechnology. Tokyo: Springer Verlag. p.321-241.  
<LI>Kim, I., Chen, Y.R., <STRONG>Kim, M.S.</STRONG>, and Kang, S. 2002. Application of hyperspectral fluorescence imaging for detection of skin tumors on chicken carcasses. American Society of Agricultural Engineers. ASAE Paper No. 02-3142.  
<LI><A href="/SP2UserFiles/person/3003/2002Mehl18-2ApplEngrAgr219-226.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Mehl, P.M., Chao, K., <STRONG>Kim, M.S.</STRONG>, and Chen, Y.R. 2002. Detection of defects on selected apple cultivars using hyperspectral and multispectral image analysis. Applied Engineering in Agriculture. 18(2):219-226. </LI></OL> 
<P style="TEXT-ALIGN: right"><I><A class=toolNav href="#top">go back to the top</A></I> </P> 
<H1><A name=2001></A><STRONG><FONT color=#006666>2001</FONT></STRONG> </H1> 
<OL> 
<LI>Chao, K., Mehl, P.M, <STRONG>Kim, M.S.</STRONG>, and Chen, Y.R. 2001. Detection of chicken skin tumors by multispectral imaging. In: Chen, Y.R., Tu, S.I., editors, Proceedings of SPIE, Volume 4206. Photonic Detection and Intervention Technologies for Safe Food, November 5-6, 2000, Boston, Massachusetts. 4206:214-223.  
<LI>Corp, L.A., McMurtrey, J.E., Campbell, P.E., <STRONG>Kim, M.S.</STRONG>, and Chappelle, E.W. 2001. Advances of fluorescence imaging systems for monitoring vegetation. Third International Conference on Geospatial Information on Agriculture and Forestry, Denver, Colorado, November 2001.  
<LI><STRONG>Kim, M.S.</STRONG>, K. Chao, Y.R. Chen, D.E. Chan, P.M. Mehl. 2001. Hyperspectral imaging system for food safety: Detection of fecal contamination on apples. In: Chen, Y.R., Tu, S.I., editors. Proceedings of SPIE, Volume 4206. Photonic Detection and Intervention Technologies for Safe Food, November 5-6, 2000, Boston, Massachusetts. 4206:174-184.  
<LI><A href="/SP2UserFiles/person/3003/2001Kim44-3TransASAE721-729.pdf" target=_blank><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;<STRONG>Kim, M.S.</STRONG>, Chen, Y.R., and Mehl, P.M. 2001. Hyperspectral reflectance and fluorescence imaging system for food quality and safety. Transactions of the ASAE. 44(3):721-729.  
<LI><STRONG>Kim, M.S.</STRONG>, McMurtrey, J.E., Mulchi, C.L., Daughtry, C.S.T., Chappelle, E.W., and Chen, Y.R. 2001. Steady-state multispectral fluorescence imaging system for plant leaves. Applied Optics. 40(1):157-166.  
<LI>Krizek, D., Middleton, E.M., Sandhu, R., and <STRONG>Kim, M.S.</STRONG>2001. Evaluating UV-B effects and EDU protection in cucumber leaves using fluorescence images and fluorescence emission spectra. Journal of Plant Physiology. 158(1):41-53.  
<LI>Mehl, P.M., Chao, K., <STRONG>Kim, M.S.</STRONG>, and Chen, Y.R. 2001. Detection of contamination on selected apple cultivars using reflectance hyperspectral and multispectral analysis. In: Chen, Y.R., Tu, S.I., editors. Proceedings of SPIE, Volume 4206. Photonic Detection and Intervention Technologies for Safe Food, November 5-6, 2000, Boston, Massachusetts. 4206:201-213. </LI></OL> 
<P style="TEXT-ALIGN: right"><I><A class=toolNav href="#top">go back to the top</A></I> </P> 
<H1><A name=2000></A><STRONG><FONT color=#006666>2000</FONT></STRONG> </H1> 
<OL> 
<LI>Corp, L.A., Chappelle, E.W., McMurtrey, J.E., Mulchi, C.L., Daughtry, C.S.T. and <STRONG>Kim, M.S.</STRONG>2000. Advances in fluorescence sensing systems for the remote assessment of nitrogen supply in field corn. Proc. of the Int. Geoscience and Remote Sens. Symp., IGARSS’2000 Digest 1:351-353.  
<LI><A href="/SP2UserFiles/person/3003/2000Daughtry74RemoteSensEnviron229-239.pdf"><IMG border=0 alt="click here to view the PDF of this article" align=bottom src="/images/docs/18159_18353/PDF_red.gif" width=16 height=17></A>&nbsp;Daughtry, C.S.T., Walthall, C.L., <STRONG>Kim, M.S.</STRONG>, de Colstoun, E.B., and McMurtrey, J.E. 2000. Estimating corn leaf chlorophyll concentration from leaf and canopy reflectance. Remote Sensing of Environment. 74:229-239.  
<LI>Delwiche, S.R., and <STRONG>Kim, M.S</STRONG>. 2001. Hyperspectral imaging for detection of scab in wheat. In: Proceedings of SPIE, Volume 4203. Biological Quality and Precision Agriculture II, November 6-8, 2000, Boston, Massachusetts. 4203:13-20.  
<LI>McMurtrey, J.E., Corp, L.A., <STRONG>Kim, M.S.</STRONG>, Chappelle, E.M., and Daughtry, C.S.T. 2000. Fluorescence techniques in agricultural applications. In: DeShazer, J.A., Meyer, G.E., editors. Optics in Agriculture 1999-2000, A Critical Review. Bellingham, WA: SPIE Optical Engineering Press. p.37- 64. </LI></OL> 
<P style="TEXT-ALIGN: right"><I><A class=toolNav href="#top">go back to the top</A></I> </P> 
<P> 
<HR color=#006666> 

<P></P></HR> 
<P align=center><FONT color=#006666><STRONG>Environmental Microbial and Food Safety Laboratory</STRONG><BR>Henry A. Wallace Beltsville Agricultural Research Center, Beltsville, MD 20705<BR>Phone: 301-504-5607<BR><STRONG><A class=toolNav href="/ba/emfsl">www.ars.usda.gov/ba/emfsl</A></STRONG></FONT> </P> 
<P> 
<HR color=#006666> 

<P></P></HR></STRONG></STRONG><!-- 24 September 2015 -->

Last Modified: 8/13/2016
Footer Content Back to Top of Page