[Olena-patches] oln 10.94: Doc (transform).

Index: olena/ChangeLog from Giovanni Palma &lt;giovanni(a)lrde.epita.fr&gt; * oln/transforms/fft.hh: Add comments. * oln/transforms/dwt.hh: Likewise. * oln/transforms/wavelet_coeffs.hh: Likewise. Index: olena/oln/transforms/dwt.hh --- olena/oln/transforms/dwt.hh Thu, 07 Aug 2003 02:37:23 +0200 burrus_n (oln/i/35_dwt.hh 1.2.1.4.1.10 600) +++ olena/oln/transforms/dwt.hh Tue, 16 Mar 2004 10:21:44 +0100 palma_g (oln/i/35_dwt.hh 1.2.1.4.1.10 640) @@ -1,4 +1,4 @@ -// Copyright (C) 2001, 2002, 2003 EPITA Research and Development Laboratory +// Copyright (C) 2001, 2002, 2003, 2004 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -41,6 +41,9 @@ namespace oln { + /*! + ** \brief Transform algorithm implementation. + */ namespace transforms { // macros used to define all the wavelets coefficients @@ -58,6 +61,9 @@ init(); \ } + /*! + ** \brief type of dwt to perform. + */ typedef enum { dwt_std, dwt_non_std @@ -65,34 +71,47 @@ } // end of namespace transforms + /*! + ** \brief internal stuff. + */ namespace internal { - + /// \brief Value of ln(2). static const ntg::float_d ln_2_ = 0.6931471805599453092; - // - // wavelet_coeffs_<T, N, Self> - // - ////////////////////////////////////// - + /*! + ** \brief Wavelet coefficient data structure. + ** + ** \param T Coefficients data type. + ** \param N Number of coefficients. + ** \param Self Self type. + */ template <class T, unsigned N, class Self> struct wavelet_coeffs_ { - typedef T value_t; - typedef Self self_t; + typedef T value_t; ///< \brType of data used. + typedef Self self_t; ///< \brief Self type. public: // accessors + /// \brief Accessor to ith element of g. const value_t getG(unsigned i) const { return g[i]; } + /// \brief Accessor to ith element of ig. const value_t getInvG(unsigned i) const { return ig[i]; } + /// \brief Accessor to ith element of h. const value_t getH(unsigned i) const { return h[i]; } + /// \brief Accessor to ith element of ih. const value_t getInvH(unsigned i) const { return ih[i]; } - + /// \brief Give the size of the arrays. const unsigned size() const { return size_; } protected: - + /*! + ** \brief Initialization method. + ** + ** Fill coefficients. + */ void init() { for (unsigned i = 0; i < size_; i += 2) { @@ -105,28 +124,46 @@ } } + /*! + ** \brief Constructor. + */ wavelet_coeffs_(){} + /*! + ** \brief Destructor. + ** + ** Its aim is to check N is pair. + */ ~wavelet_coeffs_() { mlc::is_false<N % 2>::ensure(); } - mlc::array1d< mlc::array1d_info<N>, value_t> h; - mlc::internal::array1d_start_<value_t> wc_start; + mlc::array1d< mlc::array1d_info<N>, value_t> h; /// \brief array of value_t. + mlc::internal::array1d_start_<value_t> wc_start; /// \brief First coefficient. private: - value_t g[N]; - value_t ih[N]; - value_t ig[N]; + value_t g[N]; /// \brief array of value_t. + value_t ih[N]; /// \brief array of value_t. + value_t ig[N]; /// \brief array of value_t. enum { size_ = N }; }; - // _dwt_transform_step - + /*! + ** \brief Step of a dwt transform. + ** + ** \param I Exact type of the input image. + ** \param K type of coefficients. + ** + ** \arg im Image to process. + ** \arg p_ Point to work on. + ** \arg d Component d of p. + ** \arg n Step number. + ** \arg coeffs Coefficients. + */ template <class I, class K> void dwt_transform_step_(abstract::image<I>& im, const oln_point_type(I)& p_, @@ -169,8 +206,18 @@ delete[] tmp; } - // _dwt_transform_inv_step - + /*! + ** \brief Step of a dwt invert transform. + ** + ** \param I Exact type of the input image. + ** \param K type of coefficients. + ** + ** \arg im Image to process. + ** \arg p_ Point to work on. + ** \arg d Component d of p. + ** \arg n Step number. + ** \arg coeffs Coefficients. + */ template <class I, class K> void dwt_transform_inv_step_(abstract::image<I>& im, const oln_point_type(I)& p_, @@ -217,16 +264,28 @@ } // Functions used to iterate over all dimensions except one - + /*! + ** \brief Enum to know if you go in forward or backward order. + */ typedef enum { dwt_fwd, dwt_bwd } dwt_transform_dir_; + /*! + ** \brief Functions used to iterate over all dimensions except one. + ** + ** \param dim Number of dimension to treat. + ** \param skip Dimension to skip. + ** \param current Current dimension. + */ template <unsigned dim, unsigned skip, unsigned current = dim> struct dim_skip_iterate_rec_ { + /*! + ** \brief Iterate over all dimensions except one. + */ template <class I, class K> static void doit(abstract::image<I>& im, oln_point_type(I)& p, @@ -249,9 +308,24 @@ } }; + /*! + ** \brief Specialization of dim_skip_iterate_rec_ with current + ** dimension set to 0. + ** + ** \param dim Number of dimension to process. + ** \param skip Dimension to skip. + */ template <unsigned dim, unsigned skip> struct dim_skip_iterate_rec_<dim, skip, 0> { + /*! + ** \brief Iterate over all dimensions except one. + ** + ** \param I Exact type of the image to process. + ** \param K Type of coefficients. + ** + ** It is leaf call, thus you can call a dwt transform step. + */ template <class I, class K> static void doit(abstract::image<I>& im, oln_point_type(I)& p, @@ -275,9 +349,21 @@ } }; + /*! + ** \brief Iterate over all dimensions except one. + ** + ** \param dim Number of dimension to process. + ** \param skip Dimension to skip. + */ template <unsigned dim, unsigned skip> struct dim_iterate_rec_ { + /*! + ** \brief Iterate over all dimensions except one. + ** + ** \param I Exact type of the image to process. + ** \param K Type of coefficients. + */ template <class I, class K> static void doit(abstract::image<I>& im, oln_point_type(I)& p, @@ -291,9 +377,24 @@ } }; + /*! + ** \brief Specialization of dim_iterate_rec_ with skip dimension + ** set to 0. + ** + ** \param dim Number of dimension to process. + */ template <unsigned dim> struct dim_iterate_rec_<dim, 0> { + + /*! + ** \brief Iterate over all dimensions except one. + ** + ** \param I Exact type of the image to process. + ** \param K Type of coefficients. + ** + ** End of recursion. + */ template <class I, class K> static void doit(abstract::image<I>& , oln_point_type(I)& , @@ -306,6 +407,12 @@ } }; + /*! + ** \brief Internal dwt transform function. + ** + ** \param I Exact type of the image to process. + ** \param K Type of coefficients. + */ template <class I, class K> void dwt_transform_(abstract::image<I>& im, const unsigned l1, @@ -326,6 +433,12 @@ } } + /*! + ** \brief Internal dwt invert transform function. + ** + ** \param I Exact type of the image to process. + ** \param K Type of coefficients. + */ template <class I, class K> void dwt_transform_inv_(abstract::image<I>& im, const unsigned l1, @@ -350,21 +463,29 @@ namespace transforms { - // - // dwt<T, K> - // - ////////////////////////////////////// - + /*! + ** \brief Object to compute dwt transforms. + ** + ** \param I Exact type of the image to process. + ** \param K Type of coefficients. + */ template <class I, class K> class dwt { public: - typedef I original_im_t; - typedef oln_value_type(I) original_im_value_t; - typedef typename mute<I, ntg::float_d>::ret trans_im_t; - typedef typename K::self_t coeffs_t; - + typedef I original_im_t; ///< \brief Exact of the image. + typedef oln_value_type(I) original_im_value_t; ///< \brief Original data type of the image. + typedef typename mute<I, ntg::float_d>::ret trans_im_t; ///< \brief Type of the transformed image. + typedef typename K::self_t coeffs_t; ///< \brief Data type of coefficients. + + /*! + ** \brief Constructor from an image. + ** + ** Initialization of dwt transform. + ** + ** \arg im Image to process. + */ dwt(const original_im_t& im) : original_im(im) { ntg_is_a(original_im_value_t, ntg::real)::ensure(); @@ -384,16 +505,33 @@ trans_im = trans_im_t(im.size()); } + /*! + ** \brief Accessor to the transformed image. + ** + ** Const version. + */ const trans_im_t transformed_image() const { return trans_im; } + /*! + ** \brief Accessor to the transformed image. + ** + ** Non const version. + */ trans_im_t& transformed_image() { return trans_im; } + /*! + ** \brief Compute the dwt transform. + ** + ** \arg t Type of the transform (standard or non standard) + ** \arg normalized Do you want a normalized result ? + ** \arg l Level. + */ trans_im_t transform(dwt_transform_type t = dwt_non_std, bool normalized = true, unsigned l = 0) { @@ -407,6 +545,7 @@ } oln_iter_type(trans_im_t) it(trans_im); + if (normalized) { norm = pow(sqrt(2), original_im_t::dim * l); for_all(it) @@ -426,6 +565,11 @@ return trans_im; } + /*! + ** \brief Compute the invert dwt transform. + ** + ** \arg l Level. + */ trans_im_t transform_inv(unsigned l = 0) { if (l == 0) @@ -435,6 +579,7 @@ trans_im_t new_im(trans_im.size()); oln_iter_type(trans_im_t) it(trans_im); + if (norm != 1) { for_all(it) new_im[it] = trans_im[it] * norm; @@ -451,6 +596,13 @@ return new_im; } + /*! + ** \brief Compute the invert dwt transform. + ** + ** \param T1 Data type you want the output image contains. + ** + ** \arg l Level. + */ template <class T1> typename mute<I, T1>::ret transform_inv(unsigned l = 0) { @@ -460,6 +612,7 @@ typename mute<I, T1>::ret new_im(tmp_im.size()); oln_iter_type(trans_im_t) it(tmp_im); + for_all(it) new_im[it] = (tmp_im[it] >= ntg_inf_val(T1) ? (tmp_im[it] <= ntg_sup_val(T1) ? @@ -471,14 +624,14 @@ private: - const original_im_t& original_im; - trans_im_t trans_im; - const coeffs_t coeffs; - unsigned im_size; - unsigned max_level; - unsigned current_level; - ntg::float_d norm; - dwt_transform_type transform_type; + const original_im_t& original_im; ///< The original image. + trans_im_t trans_im; ///< The transformed image. + const coeffs_t coeffs; ///< The coefficients. + unsigned im_size; ///< Size of the image. + unsigned max_level; ///< Higher level. + unsigned current_level; ///< Current level. + ntg::float_d norm; ///< Norm. + dwt_transform_type transform_type; ///< Type of transform wanted. }; } // end of namespace transforms Index: olena/oln/transforms/fft.hh --- olena/oln/transforms/fft.hh Thu, 07 Aug 2003 02:37:23 +0200 burrus_n (oln/i/36_fft.hh 1.4.1.8 600) +++ olena/oln/transforms/fft.hh Tue, 16 Mar 2004 11:56:19 +0100 palma_g (oln/i/36_fft.hh 1.4.1.8 640) @@ -1,4 +1,4 @@ -// Copyright (C) 2001, 2002, 2003 EPITA Research and Development Laboratory +// Copyright (C) 2001, 2002, 2003, 2004 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -46,46 +46,73 @@ namespace internal { - // dispatch traits for fftw - + /// \brief dispatch traits for fftw enum fft_dispatch { fft_cplx, fft_real }; + /*! + ** \brief fft trait. + */ template <class T> struct fft_trait { void ensure() { ntg_is_a(T, ntg::real)::ensure(); } - static const fft_dispatch which = fft_real; - typedef fftw_real fftw_input; + static const fft_dispatch which = fft_real; ///< Real dispatch. + typedef fftw_real fftw_input; ///< Type of input. }; + /*! + ** \brief fft trait. + ** + ** \specialization for ntg::cplx<R, T> + */ template <ntg::cplx_representation R, class T> struct fft_trait<ntg::cplx<R, T> > { - static const fft_dispatch which = fft_cplx; - typedef fftw_complex fftw_input; + static const fft_dispatch which = fft_cplx; ///< Complex dispatch. + typedef fftw_complex fftw_input; ///< Type of input. }; - // - // _fft<ntg::cplx_representation, T> - // - ////////////////////////////////////// - + /*! + ** _fft<ntg::cplx_representation, T> + ** + ** \param T Data type. + ** \param R type of representation. + */ template <class T, ntg::cplx_representation R> class _fft { public: - + /*! + ** \brief Accessor to transformed image. + ** + ** Const version. + */ const image2d<ntg::cplx<R, ntg::float_d> > transformed_image() const { return trans_im; } + /*! + ** \brief Accessor to transformed image. + ** + ** Non const version. + */ image2d<ntg::cplx<R, ntg::float_d> >& transformed_image() { return trans_im; } + /*! + ** \brief Accessor to transformed image. + ** + ** For each point p of the transformed image T, you get + ** |T[p]|. + ** + ** \param T1 Data type of the resulting image. + ** + ** \arg ordered Kind of traversal. + */ template <class T1> image2d<T1> transformed_image_magn(bool ordered = true) const { @@ -110,11 +137,30 @@ return new_im; } + /*! + ** \brief Accessor to transformed image. + ** + ** For each point p of the transformed image T, you get + ** |T[p]|. + ** + ** \arg ordered Kind of traversal. + */ image2d<T> transformed_image_magn(bool ordered = true) const { return transformed_image_magn<T>(ordered); } + /*! + ** \brief Accessor to transformed image. + ** + ** For each point p of the transformed image T, you get + ** a clipped value of |T[p]|.\n + ** + ** \param T1 Data type of the resulting image. + ** + ** \arg clip Value used for clipping. + ** \arg ordered Kind of traversal. + */ template <class T1> image2d<T1> transformed_image_clipped_magn(const ntg::float_d clip, bool ordered = true) const @@ -158,24 +204,63 @@ return new_im; } + /*! + ** \brief Accessor to transformed image. + ** + ** For each point p of the transformed image T, you get + ** a clipped value of |T[p]|.\n + ** + ** \arg clip Value used for clipping. + ** \arg ordered Kind of traversal. + */ image2d<T> transformed_image_clipped_magn(const ntg::float_d clip, bool ordered = true) const { return transformed_image_clipped_magn<T>(clip, ordered); } + /*! + ** \brief Accessor to transformed image. + ** + ** For each point p of the transformed image T, you get + ** a clipped value of |T[p]|.\n + ** + ** \param T1 Data type of the resulting image. + ** + ** \arg ordered Kind of traversal. + */ template <class T1> image2d<T1> transformed_image_clipped_magn(bool ordered = true) const { return transformed_image_clipped_magn<T1>(1, ordered); } + /*! + ** \brief Accessor to transformed image. + ** + ** For each point p of the transformed image T, you get + ** a clipped value of |T[p]|.\n + ** + ** \param T1 Data type of the resulting image. + ** + ** \arg ordered Kind of traversal. + */ image2d<T> transformed_image_clipped_magn(bool ordered = true) const { return transformed_image_clipped_magn<T>(1, ordered); } // FIXME: Find a more elegant way to fix range interval on a and b. + /*! + ** \brief Accessor to transformed image. + ** + ** For each point p of the transformed image T, you get + ** a log translated value of |T[p]| on interval [a; b].\n + ** + ** \arg a Lower bound. + ** \arg b Upper bound. + ** \arg ordered Kind of traversal. + */ template <class T1> image2d<T1> transformed_image_log_magn(const ntg::range<ntg::float_d, ntg::bounded_u<0, 1000>, @@ -213,6 +298,16 @@ } // FIXME: Find a more elegant way to fix boundaries of a and b. + /*! + ** \brief Accessor to transformed image. + ** + ** For each point p of the transformed image T, you get + ** a log translated value of |T[p]| on interval [a; b].\n + ** + ** \arg a Lower bound. + ** \arg b Upper bound. + ** \arg ordered Kind of traversal. + */ image2d<T> transformed_image_log_magn(const ntg::range<ntg::float_d, ntg::bounded_u<0, 1000>, ntg::saturate> a, @@ -224,17 +319,40 @@ return transformed_image_log_magn<T>(a, b, ordered); } + /*! + ** \brief Accessor to transformed image. + ** + ** For each point p of the transformed image T, you get + ** a log translated value of |T[p]| on interval [1; 100].\n + ** + ** \param T1 Data type of the resulting image. + ** + ** \arg ordered Kind of traversal. + */ template <class T1> image2d<T1> transformed_image_log_magn(bool ordered = true) const { return transformed_image_log_magn<T1>(1, 100, ordered); } + /*! + ** \brief Accessor to transformed image. + ** + ** For each point p of the transformed image T, you get + ** a log translated value of |T[p]| on interval [1; 100].\n + ** + ** \arg ordered Kind of traversal. + */ image2d<T> transformed_image_log_magn(bool ordered = true) const { return transformed_image_log_magn<T>(1, 100, ordered); } + /*! + ** \brief Destructor. + ** + ** Let memory free for other big images !!! + */ ~_fft() { delete [] in; @@ -245,11 +363,11 @@ protected: - typename fft_trait<T>::fftw_input *in; - fftw_complex *out; - fftwnd_plan p; - fftwnd_plan p_inv; - image2d<ntg::cplx<R, ntg::float_d> > trans_im; + typename fft_trait<T>::fftw_input *in; ///< Input image. + fftw_complex *out; ///< Complex image. + fftwnd_plan p; ///< Plan. + fftwnd_plan p_inv; ///< inverted plan. + image2d<ntg::cplx<R, ntg::float_d> > trans_im; ///< Transformed image. }; @@ -257,22 +375,37 @@ namespace transforms { + /*! + ** \brief fft class declaration. + ** + ** \param T Data type. + ** \param R Complex representation kind. + ** \param which Dispatch. + */ template <class T, ntg::cplx_representation R = ntg::polar, internal::fft_dispatch which = internal::fft_trait<T>::which > class fft; - // - // fft<T, ntg::cplx_representation, fft_real> - // - ////////////////////////////////////// - + /*! + ** \brief fft specialization for fft real dispatch. + ** + ** \param T Data type. + ** \param R Complex representation kind. + */ template <class T, ntg::cplx_representation R> class fft<T, R, internal::fft_real> : public internal::_fft<T, R> { public: + /*! + ** \brief Constructor. + ** + ** Initialization of data in order to compute the fft. + ** + ** \arg original_im Image to process. + */ fft(const image2d<T>& original_im) { this->in = new fftw_real[original_im.nrows() * original_im.ncols()]; @@ -291,6 +424,9 @@ this->trans_im = image2d<ntg::cplx<R, ntg::float_d> >(original_im.size()); } + /*! + ** \brief Compute and return the transform. + */ image2d<ntg::cplx<R, ntg::float_d> > transform() { rfftwnd_one_real_to_complex(this->p, this->in, this->out); @@ -313,6 +449,11 @@ return this->trans_im; } + /*! + ** \brief Compute and return the invert transform. + ** + ** \param T1 Data type of output image. + */ template <class T1> image2d<T1> transform_inv() { @@ -343,6 +484,9 @@ return new_im; } + /*! + ** \brief Compute and return the invert transform. + */ image2d<T> transform_inv() { return transform_inv<T>(); @@ -350,17 +494,25 @@ }; - // - // fft<T, ntg::cplx_representation, fft_cplx> - // - ////////////////////////////////////// - + /*! + ** \brief fft specialization for fft complex dispatch. + ** + ** \param T Data type. + ** \param R Complex representation kind. + */ template <class T, ntg::cplx_representation R> class fft<T, R, internal::fft_cplx> : public internal::_fft<T, R> { public: + /*! + ** \brief Constructor. + ** + ** Initialization of data in order to compute the fft. + ** + ** \arg original_im Image to process. + */ template <ntg::cplx_representation R1> fft(const image2d<ntg::cplx<R1, T> >& original_im) { @@ -384,6 +536,9 @@ this->trans_im = image2d<ntg::cplx<ntg::rect, ntg::float_d> >(original_im.size()); } + /*! + ** \brief Compute and return the transform. + */ image2d<ntg::cplx<R, ntg::float_d> > transform() { fftwnd_one(this->p, this->in, this->out); @@ -402,6 +557,11 @@ return this->trans_im; } + /*! + ** \brief Compute and return the invert transform. + ** + ** \param T1 Data type of output image. + */ template <class T1> image2d<ntg::cplx<R, T1> > transform_inv() { @@ -424,6 +584,9 @@ return new_im; } + /*! + ** \brief Compute and return the invert transform. + */ image2d<ntg::cplx<R, T> > transform_inv() { return transform_inv<T>(); Index: olena/oln/transforms/wavelet_coeffs.hh --- olena/oln/transforms/wavelet_coeffs.hh Thu, 07 Aug 2003 02:37:23 +0200 burrus_n (oln/i/34_wavelet_co 1.7 600) +++ olena/oln/transforms/wavelet_coeffs.hh Tue, 16 Mar 2004 10:25:12 +0100 palma_g (oln/i/34_wavelet_co 1.7 640) @@ -1,4 +1,4 @@ -// Copyright (C) 2001, 2002, 2003 EPITA Research and Development Laboratory +// Copyright (C) 2001, 2002, 2003, 2004 EPITA Research and Development Laboratory // // This file is part of the Olena Library. This library is free // software; you can redistribute it and/or modify it under the terms @@ -39,11 +39,9 @@ namespace transforms { - // - // Haar wavelet coefficients - // - ////////////////////////////////////// - + /*! + ** \brief Haar wavelet coefficients + */ Wavelet_coeffs_definition(haar, ntg::float_d, 2) { const ntg::float_d sqrt_2 = sqrt(2); @@ -55,11 +53,11 @@ }; - // - // Daubechies wavelet coefficients - // - ////////////////////////////////////// - + /*! + ** \brief Daubechies wavelet coefficients + ** + ** Four coefficients version. + */ Wavelet_coeffs_definition(daub4, ntg::float_d, 4) { const ntg::float_d sqrt_3 = sqrt(3); @@ -73,6 +71,11 @@ Wavelet_coeffs_end }; + /*! + ** \brief Daubechies wavelet coefficients + ** + ** Six coefficients version. + */ Wavelet_coeffs_definition(daub6, ntg::float_d, 6) { Wavelet_coeffs_begin @@ -85,6 +88,11 @@ Wavelet_coeffs_end }; + /*! + ** \brief Daubechies wavelet coefficients + ** + ** Eight coefficients version. + */ Wavelet_coeffs_definition(daub8, ntg::float_d, 8) { Wavelet_coeffs_begin @@ -99,6 +107,11 @@ Wavelet_coeffs_end }; + /*! + ** \brief Daubechies wavelet coefficients + ** + ** Ten coefficients version. + */ Wavelet_coeffs_definition(daub10, ntg::float_d, 10) { Wavelet_coeffs_begin @@ -115,6 +128,11 @@ Wavelet_coeffs_end }; + /*! + ** \brief Daubechies wavelet coefficients + ** + ** Twelve coefficients version. + */ Wavelet_coeffs_definition(daub12, ntg::float_d, 12) { Wavelet_coeffs_begin @@ -133,6 +151,11 @@ Wavelet_coeffs_end }; + /*! + ** \brief Daubechies wavelet coefficients + ** + ** Twenty coefficients version. + */ Wavelet_coeffs_definition(daub20, ntg::float_d, 20) { Wavelet_coeffs_begin @@ -160,11 +183,11 @@ }; - // - // Coifman wavelet coefficients - // - ////////////////////////////////////// - + /*! + ** \brief Coifman wavelet coefficients + ** + ** Six coefficients version. + */ Wavelet_coeffs_definition(coiflet2, ntg::float_d, 6) { const ntg::float_d sqrt_2 = sqrt(2); @@ -180,6 +203,11 @@ Wavelet_coeffs_end }; + /*! + ** \brief Coifman wavelet coefficients + ** + ** Twelve coefficients version. + */ Wavelet_coeffs_definition(coiflet4, ntg::float_d, 12) { Wavelet_coeffs_begin @@ -198,6 +226,11 @@ Wavelet_coeffs_end }; + /*! + ** \brief Coifman wavelet coefficients + ** + ** Eighteen coefficients version. + */ Wavelet_coeffs_definition(coiflet6, ntg::float_d, 18) { Wavelet_coeffs_begin -- Giovanni Palma EPITA - promo 2005 - membre d'EpX - LRDE Mob. : +33 (0)6 60 97 31 74