mpicbg-trakem2/src/main/java/mpicbg/trakem2/transform/TransformMeshMappingWithMasks.java

   1 /**
   2  * License: GPL
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License 2
   6  * as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  16  */
  17 package mpicbg.trakem2.transform;
  18
  19 import ij.process.ByteProcessor;
  20 import ij.process.ImageProcessor;
  21 import ij.process.ShortProcessor;
  22
  23 import java.util.ArrayList;
  24 import java.util.HashMap;
  25 import java.util.List;
  26 import java.util.concurrent.atomic.AtomicInteger;
  27
  28 import mpicbg.models.AffineModel2D;
  29 import mpicbg.models.PointMatch;
  30 import mpicbg.models.TransformMesh;
  31 import mpicbg.util.Util;
  32
  33 /**
  34  * Specialized {@link mpicbg.ij.TransformMapping} for Patches, that is, rendering
  35  * the image, outside mask and mask in one go instead three.
  36  *
  37  * @author Stephan Saalfeld <saalfeld@mpi-cbg.de>
  38  * @version 0.1a
  39  */
  40 public class TransformMeshMappingWithMasks< T extends TransformMesh > extends mpicbg.ij.TransformMeshMapping< T >
  41 {
  42         final static public class ImageProcessorWithMasks
  43         {
  44                 final public ImageProcessor ip;
  45                 public ByteProcessor outside = null;
  46                 public ImageProcessor mask = null;
  47
  48                 public ImageProcessorWithMasks( final ImageProcessor ip, final ImageProcessor mask, final ByteProcessor outside )
  49                 {
  50                         this.ip = ip;
  51                         if ( outside != null )
  52                         {
  53                                 if ( ip.getWidth() == outside.getWidth() && ip.getHeight() == outside.getHeight() )
  54                                         this.outside = outside;
  55                                 else
  56                                         System.err.println( "ImageProcessorWithMasks: ip and outside mask differ in size, setting outside = null" );
  57                         }
  58                         if ( mask != null )
  59                         {
  60                                 if ( ip.getWidth() == mask.getWidth() && ip.getHeight() == mask.getHeight() )
  61                                         this.mask = mask;
  62                                 else
  63                                         System.err.println( "ImageProcessorWithMasks: ip and mask differ in size, setting mask = null" );
  64                         }
  65                 }
  66
  67                 final public int getWidth(){ return ip.getWidth(); }
  68                 final public int getHeight(){ return ip.getHeight(); }
  69         }
  70
  71         final static private class MapTriangleThread extends Thread
  72         {
  73                 final private AtomicInteger i;
  74                 final private List< AffineModel2D > triangles;
  75                 final private TransformMesh transform;
  76                 final ImageProcessorWithMasks source, target;
  77                 MapTriangleThread(
  78                                 final AtomicInteger i,
  79                                 final List< AffineModel2D > triangles,
  80                                 final TransformMesh transform,
  81                                 final ImageProcessorWithMasks source,
  82                                 final ImageProcessorWithMasks target )
  83                 {
  84                         this.i = i;
  85                         this.triangles = triangles;
  86                         this.transform = transform;
  87                         this.source = source;
  88                         this.target = target;
  89                 }
  90
  91                 @Override
  92                 final public void run()
  93                 {
  94                         int k = i.getAndIncrement();
  95                         while ( !isInterrupted() && k < triangles.size() )
  96                         {
  97                                 if ( source.mask == null )
  98                                         mapTriangle( transform, triangles.get( k ), source.ip, target.ip, target.outside );
  99                                 else
 100                                         mapTriangle( transform, triangles.get( k ), source.ip, source.mask, target.ip, target.mask, target.outside );
 101                                 k = i.getAndIncrement();
 102                         }
 103                 }
 104         }
 105
 106         final static private class MapTriangleInterpolatedThread extends Thread
 107         {
 108                 final private AtomicInteger i;
 109                 final private List< AffineModel2D > triangles;
 110                 final private TransformMesh transform;
 111                 final ImageProcessorWithMasks source, target;
 112                 MapTriangleInterpolatedThread(
 113                                 final AtomicInteger i,
 114                                 final List< AffineModel2D > triangles,
 115                                 final TransformMesh transform,
 116                                 final ImageProcessorWithMasks source,
 117                                 final ImageProcessorWithMasks target )
 118                 {
 119                         this.i = i;
 120                         this.triangles = triangles;
 121                         this.transform = transform;
 122                         this.source = source;
 123                         this.target = target;
 124                 }
 125
 126                 @Override
 127                 final public void run()
 128                 {
 129                         int k = i.getAndIncrement();
 130                         while ( !isInterrupted() && k < triangles.size() )
 131                         {
 132                                 if ( source.mask == null )
 133                                         mapTriangleInterpolated( transform, triangles.get( k ), source.ip, target.ip, target.outside );
 134                                 else
 135                                         mapTriangleInterpolated( transform, triangles.get( k ), source.ip, source.mask, target.ip, target.mask, target.outside );
 136                                 k = i.getAndIncrement();
 137                         }
 138                 }
 139         }
 140
 141         final static private class MapShortAlphaTriangleThread extends Thread
 142         {
 143                 final private AtomicInteger i;
 144                 final private List< AffineModel2D > triangles;
 145                 final private TransformMesh transform;
 146                 final ShortProcessor source, target;
 147                 final ByteProcessor alpha;
 148                 MapShortAlphaTriangleThread(
 149                                 final AtomicInteger i,
 150                                 final List< AffineModel2D > triangles,
 151                                 final TransformMesh transform,
 152                                 final ShortProcessor source,
 153                                 final ByteProcessor alpha,
 154                                 final ShortProcessor target )
 155                 {
 156                         this.i = i;
 157                         this.triangles = triangles;
 158                         this.transform = transform;
 159                         this.source = source;
 160                         this.alpha = alpha;
 161                         this.target = target;
 162                 }
 163
 164                 @Override
 165                 final public void run()
 166                 {
 167                         int k = i.getAndIncrement();
 168                         while ( !isInterrupted() && k < triangles.size() )
 169                         {
 170                                 mapShortAlphaTriangle( transform, triangles.get( k ), source, alpha, target );
 171                                 k = i.getAndIncrement();
 172                         }
 173                 }
 174         }
 175
 176         public TransformMeshMappingWithMasks( final T t )
 177         {
 178                 super( t );
 179         }
 180
 181         final static protected void mapTriangle(
 182                         final TransformMesh m,
 183                         final AffineModel2D ai,
 184                         final ImageProcessor source,
 185                         final ImageProcessor target,
 186                         final ByteProcessor targetOutside )
 187         {
 188                 final int w = target.getWidth() - 1;
 189                 final int h = target.getHeight() - 1;
 190                 final ArrayList< PointMatch > pm = m.getAV().get( ai );
 191                 final float[] min = new float[ 2 ];
 192                 final float[] max = new float[ 2 ];
 193                 calculateBoundingBox( pm, min, max );
 194
 195                 final int minX = Math.max( 0, Util.roundPos( min[ 0 ] ) );
 196                 final int minY = Math.max( 0, Util.roundPos( min[ 1 ] ) );
 197                 final int maxX = Math.min( w, Util.roundPos( max[ 0 ] ) );
 198                 final int maxY = Math.min( h, Util.roundPos( max[ 1 ] ) );
 199
 200                 final float[] a = pm.get( 0 ).getP2().getW();
 201                 final float ax = a[ 0 ];
 202                 final float ay = a[ 1 ];
 203                 final float[] b = pm.get( 1 ).getP2().getW();
 204                 final float bx = b[ 0 ];
 205                 final float by = b[ 1 ];
 206                 final float[] c = pm.get( 2 ).getP2().getW();
 207                 final float cx = c[ 0 ];
 208                 final float cy = c[ 1 ];
 209                 final float[] t = new float[ 2 ];
 210                 for ( int y = minY; y <= maxY; ++y )
 211                 {
 212                         for ( int x = minX; x <= maxX; ++x )
 213                         {
 214                                 if ( isInTriangle( ax, ay, bx, by, cx, cy, x, y ) )
 215                                 {
 216                                         t[ 0 ] = x;
 217                                         t[ 1 ] = y;
 218                                         try
 219                                         {
 220                                                 ai.applyInverseInPlace( t );
 221                                         }
 222                                         catch ( final Exception e )
 223                                         {
 224                                                 //e.printStackTrace( System.err );
 225                                                 continue;
 226                                         }
 227                                         target.set( x, y, source.getPixel( ( int )( t[ 0 ] + 0.5f ), ( int )( t[ 1 ] + 0.5f ) ) );
 228                                         targetOutside.set( x, y, 0xff );
 229                                 }
 230                         }
 231                 }
 232         }
 233
 234         final static protected void mapTriangleInterpolated(
 235                         final TransformMesh m,
 236                         final AffineModel2D ai,
 237                         final ImageProcessor source,
 238                         final ImageProcessor target,
 239                         final ByteProcessor targetOutside )
 240         {
 241                 final int w = target.getWidth() - 1;
 242                 final int h = target.getHeight() - 1;
 243                 final ArrayList< PointMatch > pm = m.getAV().get( ai );
 244                 final float[] min = new float[ 2 ];
 245                 final float[] max = new float[ 2 ];
 246                 calculateBoundingBox( pm, min, max );
 247
 248                 final int minX = Math.max( 0, Util.roundPos( min[ 0 ] ) );
 249                 final int minY = Math.max( 0, Util.roundPos( min[ 1 ] ) );
 250                 final int maxX = Math.min( w, Util.roundPos( max[ 0 ] ) );
 251                 final int maxY = Math.min( h, Util.roundPos( max[ 1 ] ) );
 252
 253                 final float[] a = pm.get( 0 ).getP2().getW();
 254                 final float ax = a[ 0 ];
 255                 final float ay = a[ 1 ];
 256                 final float[] b = pm.get( 1 ).getP2().getW();
 257                 final float bx = b[ 0 ];
 258                 final float by = b[ 1 ];
 259                 final float[] c = pm.get( 2 ).getP2().getW();
 260                 final float cx = c[ 0 ];
 261                 final float cy = c[ 1 ];
 262                 final float[] t = new float[ 2 ];
 263                 for ( int y = minY; y <= maxY; ++y )
 264                 {
 265                         for ( int x = minX; x <= maxX; ++x )
 266                         {
 267                                 if ( isInTriangle( ax, ay, bx, by, cx, cy, x, y ) )
 268                                 {
 269                                         t[ 0 ] = x;
 270                                         t[ 1 ] = y;
 271                                         try
 272                                         {
 273                                                 ai.applyInverseInPlace( t );
 274                                         }
 275                                         catch ( final Exception e )
 276                                         {
 277                                                 //e.printStackTrace( System.err );
 278                                                 continue;
 279                                         }
 280                                         target.set( x, y, source.getPixelInterpolated( t[ 0 ], t[ 1 ] ) );
 281                                         targetOutside.set( x, y, 0xff );
 282                                 }
 283                         }
 284                 }
 285         }
 286
 287
 288         final static protected void mapTriangle(
 289                         final TransformMesh m,
 290                         final AffineModel2D ai,
 291                         final ImageProcessor source,
 292                         final ImageProcessor sourceMask,
 293                         final ImageProcessor target,
 294                         final ImageProcessor targetMask,
 295                         final ByteProcessor targetOutside )
 296         {
 297                 final int w = target.getWidth() - 1;
 298                 final int h = target.getHeight() - 1;
 299                 final ArrayList< PointMatch > pm = m.getAV().get( ai );
 300                 final float[] min = new float[ 2 ];
 301                 final float[] max = new float[ 2 ];
 302                 calculateBoundingBox( pm, min, max );
 303
 304                 final int minX = Math.max( 0, Util.roundPos( min[ 0 ] ) );
 305                 final int minY = Math.max( 0, Util.roundPos( min[ 1 ] ) );
 306                 final int maxX = Math.min( w, Util.roundPos( max[ 0 ] ) );
 307                 final int maxY = Math.min( h, Util.roundPos( max[ 1 ] ) );
 308
 309                 final float[] a = pm.get( 0 ).getP2().getW();
 310                 final float ax = a[ 0 ];
 311                 final float ay = a[ 1 ];
 312                 final float[] b = pm.get( 1 ).getP2().getW();
 313                 final float bx = b[ 0 ];
 314                 final float by = b[ 1 ];
 315                 final float[] c = pm.get( 2 ).getP2().getW();
 316                 final float cx = c[ 0 ];
 317                 final float cy = c[ 1 ];
 318                 final float[] t = new float[ 2 ];
 319                 for ( int y = minY; y <= maxY; ++y )
 320                 {
 321                         for ( int x = minX; x <= maxX; ++x )
 322                         {
 323                                 if ( isInTriangle( ax, ay, bx, by, cx, cy, x, y ) )
 324                                 {
 325                                         t[ 0 ] = x;
 326                                         t[ 1 ] = y;
 327                                         try
 328                                         {
 329                                                 ai.applyInverseInPlace( t );
 330                                         }
 331                                         catch ( final Exception e )
 332                                         {
 333                                                 //e.printStackTrace( System.err );
 334                                                 continue;
 335                                         }
 336                                         target.set( x, y, source.getPixel( ( int )( t[ 0 ] + 0.5f ), ( int )( t[ 1 ] + 0.5f ) ) );
 337                                         targetOutside.set( x, y, 0xff );
 338                                         targetMask.set( x, y, sourceMask.getPixel( ( int )( t[ 0 ] + 0.5f ), ( int )( t[ 1 ] + 0.5f ) ) );
 339                                 }
 340                         }
 341                 }
 342         }
 343
 344         final static protected void mapTriangleInterpolated(
 345                         final TransformMesh m,
 346                         final AffineModel2D ai,
 347                         final ImageProcessor source,
 348                         final ImageProcessor sourceMask,
 349                         final ImageProcessor target,
 350                         final ImageProcessor targetMask,
 351                         final ByteProcessor targetOutside )
 352         {
 353                 final int w = target.getWidth() - 1;
 354                 final int h = target.getHeight() - 1;
 355                 final ArrayList< PointMatch > pm = m.getAV().get( ai );
 356                 final float[] min = new float[ 2 ];
 357                 final float[] max = new float[ 2 ];
 358                 calculateBoundingBox( pm, min, max );
 359
 360                 final int minX = Math.max( 0, Util.roundPos( min[ 0 ] ) );
 361                 final int minY = Math.max( 0, Util.roundPos( min[ 1 ] ) );
 362                 final int maxX = Math.min( w, Util.roundPos( max[ 0 ] ) );
 363                 final int maxY = Math.min( h, Util.roundPos( max[ 1 ] ) );
 364
 365                 final float[] a = pm.get( 0 ).getP2().getW();
 366                 final float ax = a[ 0 ];
 367                 final float ay = a[ 1 ];
 368                 final float[] b = pm.get( 1 ).getP2().getW();
 369                 final float bx = b[ 0 ];
 370                 final float by = b[ 1 ];
 371                 final float[] c = pm.get( 2 ).getP2().getW();
 372                 final float cx = c[ 0 ];
 373                 final float cy = c[ 1 ];
 374                 final float[] t = new float[ 2 ];
 375                 for ( int y = minY; y <= maxY; ++y )
 376                 {
 377                         for ( int x = minX; x <= maxX; ++x )
 378                         {
 379                                 if ( isInTriangle( ax, ay, bx, by, cx, cy, x, y ) )
 380                                 {
 381                                         t[ 0 ] = x;
 382                                         t[ 1 ] = y;
 383                                         try
 384                                         {
 385                                                 ai.applyInverseInPlace( t );
 386                                         }
 387                                         catch ( final Exception e )
 388                                         {
 389                                                 //e.printStackTrace( System.err );
 390                                                 continue;
 391                                         }
 392                                         target.set( x, y, source.getPixelInterpolated( t[ 0 ], t[ 1 ] ) );
 393                                         targetOutside.set( x, y, 0xff );
 394                                         targetMask.set( x, y, sourceMask.getPixelInterpolated( t[ 0 ], t[ 1 ] ) );
 395                                 }
 396                         }
 397                 }
 398         }
 399
 400
 401         final static protected void mapShortAlphaTriangle(
 402                         final TransformMesh m,
 403                         final AffineModel2D ai,
 404                         final ShortProcessor source,
 405                         final ByteProcessor alpha,
 406                         final ShortProcessor target )
 407         {
 408                 final int w = target.getWidth() - 1;
 409                 final int h = target.getHeight() - 1;
 410                 final ArrayList< PointMatch > pm = m.getAV().get( ai );
 411                 final float[] min = new float[ 2 ];
 412                 final float[] max = new float[ 2 ];
 413                 calculateBoundingBox( pm, min, max );
 414
 415                 final int minX = Math.max( 0, Util.roundPos( min[ 0 ] ) );
 416                 final int minY = Math.max( 0, Util.roundPos( min[ 1 ] ) );
 417                 final int maxX = Math.min( w, Util.roundPos( max[ 0 ] ) );
 418                 final int maxY = Math.min( h, Util.roundPos( max[ 1 ] ) );
 419
 420                 final float[] a = pm.get( 0 ).getP2().getW();
 421                 final float ax = a[ 0 ];
 422                 final float ay = a[ 1 ];
 423                 final float[] b = pm.get( 1 ).getP2().getW();
 424                 final float bx = b[ 0 ];
 425                 final float by = b[ 1 ];
 426                 final float[] c = pm.get( 2 ).getP2().getW();
 427                 final float cx = c[ 0 ];
 428                 final float cy = c[ 1 ];
 429                 final float[] t = new float[ 2 ];
 430                 for ( int y = minY; y <= maxY; ++y )
 431                 {
 432                         for ( int x = minX; x <= maxX; ++x )
 433                         {
 434                                 if ( isInTriangle( ax, ay, bx, by, cx, cy, x, y ) )
 435                                 {
 436                                         t[ 0 ] = x;
 437                                         t[ 1 ] = y;
 438                                         try
 439                                         {
 440                                                 ai.applyInverseInPlace( t );
 441                                         }
 442                                         catch ( final Exception e )
 443                                         {
 444                                                 //e.printStackTrace( System.err );
 445                                                 continue;
 446                                         }
 447                                         final int is = source.getPixelInterpolated( t[ 0 ], t[ 1 ] );
 448                                         final int it = target.get( x, y );
 449                                         final double f = alpha.getPixelInterpolated( t[ 0 ], t[ 1 ] ) / 255.0;
 450                                         final double v = it + f  * ( is - it );
 451                                         target.set( x, y, ( int )Math.max(  0, Math.min( 65535, Math.round( v ) ) ) );
 452                                 }
 453                         }
 454                 }
 455         }
 456
 457
 458         final public void map( final ImageProcessorWithMasks source, final ImageProcessorWithMasks target, final int numThreads )
 459         {
 460                 target.outside = new ByteProcessor( target.getWidth(), target.getHeight() );
 461                 final HashMap< AffineModel2D, ArrayList< PointMatch >> av = transform.getAV();
 462                 if ( numThreads > 1 )
 463                 {
 464                         final ArrayList< AffineModel2D > triangles = new ArrayList< AffineModel2D >( av.keySet() );
 465                         final AtomicInteger i = new AtomicInteger( 0 );
 466                         final ArrayList< Thread > threads = new ArrayList< Thread >( numThreads );
 467                         for ( int k = 0; k < numThreads; ++k )
 468                         {
 469                                 final Thread mtt = new MapTriangleThread( i, triangles, transform, source, target );
 470                                 threads.add( mtt );
 471                                 mtt.start();
 472                         }
 473                         for ( final Thread mtt : threads )
 474                         {
 475                                 try
 476                                 {
 477                                         mtt.join();
 478                                 }
 479                                 catch ( final InterruptedException e )
 480                                 {}
 481                         }
 482                 }
 483                 else if ( source.mask == null )
 484                 {
 485                         for ( final AffineModel2D triangle : av.keySet() )
 486                         {
 487                                 mapTriangle( transform, triangle, source.ip, target.ip, target.outside );
 488                         }
 489                 }
 490                 else
 491                 {
 492                         for ( final AffineModel2D triangle : av.keySet() )
 493                         {
 494                                 mapTriangle( transform, triangle, source.ip, source.mask, target.ip, target.mask, target.outside );
 495                         }
 496                 }
 497         }
 498
 499         final public void mapInterpolated( final ImageProcessorWithMasks source, final ImageProcessorWithMasks target, final int numThreads )
 500         {
 501                 target.outside = new ByteProcessor( target.getWidth(), target.getHeight() );
 502                 source.ip.setInterpolationMethod( ImageProcessor.BILINEAR );
 503                 if ( source.mask != null )
 504                 {
 505                         source.mask.setInterpolationMethod( ImageProcessor.BILINEAR );
 506                 }
 507                 final HashMap< AffineModel2D, ArrayList< PointMatch >> av = transform.getAV();
 508                 if ( numThreads > 1 )
 509                 {
 510                         final ArrayList< AffineModel2D > triangles = new ArrayList< AffineModel2D >( av.keySet() );
 511                         final AtomicInteger i = new AtomicInteger( 0 );
 512                         final ArrayList< Thread > threads = new ArrayList< Thread >( numThreads );
 513                         for ( int k = 0; k < numThreads; ++k )
 514                         {
 515                                 final Thread mtt = new MapTriangleInterpolatedThread( i, triangles, transform, source, target );
 516                                 threads.add( mtt );
 517                                 mtt.start();
 518                         }
 519                         for ( final Thread mtt : threads )
 520                         {
 521                                 try
 522                                 {
 523                                         mtt.join();
 524                                 }
 525                                 catch ( final InterruptedException e )
 526                                 {}
 527                         }
 528                 }
 529                 else if ( source.mask == null )
 530                 {
 531                         for ( final AffineModel2D triangle : av.keySet() )
 532                         {
 533                                 mapTriangleInterpolated( transform, triangle, source.ip, target.ip, target.outside );
 534                         }
 535                 }
 536                 else
 537                 {
 538                         for ( final AffineModel2D triangle : av.keySet() )
 539                         {
 540                                 mapTriangleInterpolated( transform, triangle, source.ip, source.mask, target.ip, target.mask, target.outside );
 541                         }
 542                 }
 543         }
 544
 545         final public void map(
 546                         final ImageProcessorWithMasks source,
 547                         final ImageProcessorWithMasks target )
 548         {
 549                 map( source, target, Runtime.getRuntime().availableProcessors() );
 550         }
 551
 552         final public void mapInterpolated(
 553                         final ImageProcessorWithMasks source,
 554                         final ImageProcessorWithMasks target )
 555         {
 556                 mapInterpolated( source, target, Runtime.getRuntime().availableProcessors() );
 557         }
 558
 559
 560         /**
 561          * Render source into target using alpha composition.
 562          * Interpolation is specified by the interpolation methods
 563          * set in source and alpha.
 564          *
 565          * @param source
 566          * @param alpha
 567          * @param target
 568          * @param numThreads
 569          */
 570         final public void map(
 571                         final ShortProcessor source,
 572                         final ByteProcessor alpha,
 573                         final ShortProcessor target,
 574                         final int numThreads )
 575         {
 576                 final List< AffineModel2D > l = new ArrayList< AffineModel2D >();
 577                 l.addAll( transform.getAV().keySet() );
 578                 final AtomicInteger i = new AtomicInteger( 0 );
 579                 final ArrayList< Thread > threads = new ArrayList< Thread >( numThreads );
 580                 for ( int k = 0; k < numThreads; ++k )
 581                 {
 582                         final Thread mtt = new MapShortAlphaTriangleThread( i, l, transform, source, alpha, target );
 583                         threads.add( mtt );
 584                         mtt.start();
 585                 }
 586                 for ( final Thread mtt : threads )
 587                 {
 588                         try
 589                         {
 590                                 mtt.join();
 591                         }
 592                         catch ( final InterruptedException e ) {}
 593                 }
 594         }
 595
 596
 597         /**
 598          * Render source into master using alpha composition.
 599          * Interpolation is specified by the interpolation methods
 600          * set in source and alpha.
 601          *
 602          * @param source
 603          * @param alpha
 604          * @param target
 605          */
 606         final public void map(
 607                         final ShortProcessor source,
 608                         final ByteProcessor alpha,
 609                         final ShortProcessor target )
 610         {
 611                 map( source, alpha, target, Runtime.getRuntime().availableProcessors() );
 612         }
 613 }