{ELC Comet 1.1}

{This macro analyses 16-bit images taken collected from single cell gel
electrophoresis slides (comet assay). The following parameters are calculated and
may be saved to a text file: comet's total area, total mean comet intensity, head
area, mean head intensity, tail length, Ashby's tail moment, Olive's tail moment,
Corrie's tail moment (inspired by Kent 1995), percent DNA migrated, Hellman's
inertia, Hellmans Tail DNA, Hellman's tail distance, Hellman's Tail Moment, and
the image's background level  . This program combines aspects of two current comet
macros already available along with other indices suggested in the comet
literature. On the first run through each slide, informational windows provide
guidance as to the next step of the procedure.  Afterwards, none of the guidance
boxes appear until a new slide is loaded.}

{**************************************************************************}

{Definition of global variables}

var                         
    counter:  integer;        {counts the number of  measurements per slide name}
    threshold:  integer;      {discriminates the comet from the background}
    uthreshold: integer;      {upper threshold, set to 255 in thresholding mode}
    ImageLength:  integer;    {length of image}
    ImageWidth: integer;      {width of original image}
    ImageHeight: integer;     {height of original image}
    ThisLineMax:   integer    {maximum intensity of the scanned line}
    AllLinesSum:  integer     {Running sum of line minima}
    AvgMin:       integer     {Avg minimum pixel value across all scanned lines}
    CometLeft:  integer;      {x-coordinate for the left edge of the comet}
    CometRight:  integer;     {x-coordinate for the right edge of the comet}
    CometHeight:  integer;    {height of the comet}
    CometTop:  integer;       {y-coordinate of the comet top}
    CometLength:  integer;    {length of the comet}
    TotalArea:  real;         {area of the comet}
    AvgInt:  real;            {mean intensity of the comet}
    TotalDNA:  real;          {DNA of the comet}
    Max: integer;             {maximum intensity of the comet}
    left:  integer;           {intermediate variables for }
    top:  integer;            {ROI measurements}
    width:  integer;          {used for width index of various ROIs}
    height:  integer;         {used for height index of various ROIs}
    Headx:  integer;          {x-coordinate for the head center}
    Heady:  integer;          {y-coordinate for the head center} 
    DiameterX:  integer;      {head diameter}
    DiameterY:  integer;      {head diameter}
    HeadTop:  integer;        {Y value of top of comet head}
    HeadLeft:  integer;       {X value of left side of head-away from tail}
    HeadHeight:  integer;     {height of head}
    TailLength:  integer;     {tail length
    TailX:   integer;         {center of the comet's tail}
    HeadArea:  integer;       {number of pixels in head ellipse}
    HeadInt:  integer;        {mean head intensity}
    HeadDNA:  integer;        {DNA in the head}
    HeadArm:  integer;        {running head moment}
    HeadWt:   integer;        {running head intensity}
    HeadPixels: integer;      {number of pixels for head arm and weight}
    CGHeadX:  real;           {x position of center of gravity of head}
    LCGHeadX: real;           {distance of head CG from right side of head}
    CGTailX:  real;           {x position of center of gravity of tail}
    CGDiff:  real;            {distance between head and tail CGs}
    TailStartY:  real;        {Y position of head ellipse for CTM calculations}
    TailStartX:  real;        {X position of head ellipse for CTM calculations}
    TailArea:  integer;       {number of pixels in tail as comet-head areas}
    TailPixels:   integer;    {number of pixels in tail used in CTM}
    TailDNA:  integer;        {DNA in the tail}
    TailDNAPr:  real;         {Percentage DNA in the tail}
    TailMoment: real;         {weighted intensity of tail calculated for CTM}
    TailWt: integer;          {accumulating tail weight}
    ATailMoment:  real;       {Ashby's tail moment}
    Inertia:  real;           {Hellman's inertia}
    DistanceP:  real;         {Distance in the x-axis from the center of the head}
    CTM:   real;              {Corrie's tail moment}
    OTM:   real;              {Olive's tail moment}
    TAI:   real;              {Average tail intensity}
    TDNA:   real;             {Total tail intensity}
    TD:   real;               {Tail distance}
    TMOM:   real;             {Hellman's tail moment}
    SubAvgMin: real;          {Actual background level when image inverted}
    n,i,j,k,q:  integer;        {utility counters}
    Name,Slide:  string;      {name of the data window and slide}
    T:  string;               {tab}
    CometIntensity:integer;   {sum of intensity values of entire comet}
    TD:   real;               {Tail distance, from comet head center}
    TDM:  real;               {Tail distance moment for Hellman's TD}
 
{**************************************************************************}
Procedure ERASE;    {erases the directions}

begin;
    MakeROI(2,0,1000,30);
    clear; 
    KillRoi;
    MoveTo(2,10);
    SetFont('Courier');
end;


{**************************************************************************}


Procedure NUMBER;    {adjusts the string length to eight and centers}

begin;
    i:= length(Slide);
    n:= trunc((8-i)/2);
    if n = 1  then 
        Slide:= concat(' ',Slide);
    if n = 2 then
        Slide:= concat('  ',Slide);
    if n = 3 then
        Slide:= concat('   ',Slide);
    i:= length(Slide);
    if i = 7 then
        Slide:= concat(Slide,' ');
    if i = 6 then
        Slide:= concat(Slide,'  ');
    if i = 5 then
        Slide:= concat(Slide,'   ');
    if i = 4 then
        Slide:= concat(Slide,'    ');  
end;

{**************************************************************************}
Procedure FNAME;    {creates a new text file}

begin;
    T:= chr(9);
    if Name = 'Global String' then
        Name:= 'Data';
    Name:= GetString('Enter your text file name:', name);
    Delete(name,9,20);
    i:= length(name);
    if i <= 0 then
        Name:= GetString('Please enter the file name:', name);		
    NewTextWindow(name,10,10); 
    SetFont('Courier');  

    Writeln('  ', T, '  ', T, '  ', T, 'Mean', T, '  ', T, 'Mean', T,
      '  ', T, 'Ashby', T, 'Olive', T, 'Corrie', T, 'Percent', T, 'Mean', T, T, T);
 
    Writeln('Slide', T, 'Cell', T, 'Comet', T, 'Comet', T, 'Head', T, 
      'Head', T, 'Tail', T, 'Tail', T, 'Tail', T, 'Tail  ', T, 'Migrated',
      T, 'Tail', T, 'Hellman', T, 'Hellman', T, 'Hellman', T, 'Hellman', T, 'Image');
 
    Writeln('Name', T, 'Number', T, 'Area', T, 'Intensity', T, 'Area', T,
      'Intensity', T, 'Length', T, 'Moment', T, 'Moment', T, 'Moment', T,
      'DNA', T, 'Intensity', T, 'Inertia', T, 'TDNA', T, 'TD', T, 'TMOM', T, 'Bkgnd', T, 'TDM', T, 'TailWt');

    SaveAs(name);                         {added}
    counter:= 1;
end;
 

{**************************************************************************}
Procedure SNAME;    {creates a new slide name}

begin;
    if Slide = 'Global String' then
        Slide:= 'Slide 1';
    Slide:= GetString('Enter the slide code:', slide);
    Delete(slide,9,20);
    i:= length(slide);
    if i <= 0 then
        Slide:= GetString('Enter the slide code:', slide);		 
    NUMBER;
    counter:= 1;  {starts the measurement counter at 1, doesn't reset until}
                  {a new text file is opened}
end;
{**************************************************************************}
 

macro 'Acquire an image from a file [F]';

begin
    SetFont('Courier');
    DisposeAll;  {Closes all image windows}
    Open('');    {Change to "Import('File Name')" if you have to import a file}
    SetPicName('Image'); {Names the image, uh, image}

{Create a new Data window and Slide name if it is the first measurement:}
    if counter = 0 then 
        begin
          SNAME;
          FNAME;
        end;

{Go back to the Image window}
    SelectWindow('Image');
    ResetCounter;
{Scans line by line vertically down image, finding maximums, then averaging them}
    GetPicSize(ImageWidth,ImageHeight);  {Gets dimensions of image}
    ThisLineMax:=0; AllLinesSum:=0; AvgMin:=0;   {Initializes accumulators}
      For i:= 0 to ImageHeight Do       {Scans from bottom of image to top}
         Begin
           ThisLineMax:=0;              {Sets or resets the maximum value found}
           {Since image is going to be inverted later, maximum values}
           {will become minimums}
           For j:=0 to ImageWidth Do    {Scans right to left across image}}
               Begin
                  k:=GetPixel(j,i);     {Gets pixel value at sampling position}
                     If k>ThisLineMax then  {Checks to see if new value is higher}
                                            {than highest so far}
                          ThisLineMax:=k;   {If so, make it the new highest value}
               End;
           AllLinesSum:= AllLinesSum+ThisLineMax; {Keeps a running total of all}
                                                  {lines maximum values}
         End;
    ResetCounter;
    {Average maximum values will be average minimum values when inverted}
    AvgMin:=AllLinesSum/ImageHeight;  {Calculates average maximum values}
    SubAvgMin:= (255-AvgMin); {Calculates background "subtraction" needed}
    AddConstant(SubAvgMin);  {"Subtracts" background from inverse image}
    InvertY(false);                       
    {Filter('smooth');}    {You may have to experiment with filter settings}
    Invert;              {Necessary to obtain dark comets on bright background}

{Select correct tool and window}
    SelectTool('straightline');      
    SelectWindow('Image');

begin
          PutMessage('Draw a line from the center of the nucleus through the comet tail and press R.   But first, press OK to close this box.');
          exit;
        end;
end;    

{**************************************************************************}
macro 'Rotate the Comet [R]';

var
{used to determine the direction of the comet}
    x1, x2, y1, y2, dx, dy, degrees:  integer; 
    theta, pi:  real;

begin  {This bit of code calculates the angle of the line drawn}
       {and then rotates the image to make the tails as horizontal as possible}
    q:=0;   {Sets or resets flag for nuclear marking message later}
    Pi:= 3.14159265;
    GetLine(x1,y1,x2,y2,width);  {Gets coordinates of line drawn}
      if x1<0 then               {if x1 not on picture, redraw line} 
        begin
          PutMessage('Draw a line from the center of the nucleus through the comet tail and press R.');
          exit;
        end;

    dx:= x2-x1;    {calculates slope of drawn line}
    dy:= y2-y1;
    if dx= 0
       then   {prevents divide by zero errors during arctangent}
                      {calculation if comet tail vertical}
          begin
            if dy>0 then theta:= pi/2;   {tail up, angle 90 degrees}
            if dy<0 then theta:= 3/2*pi; {tail down, angle 270 degrees}
            if dy=0 then theta:= 0;      {line really a dot, don't rotate}
          end
      {tail not vertical so do arctangent calculation to get angle}
      else theta:=arctan(dy/dx);      {simple trigonometry}        
    if theta>pi then                  {If tail pointed downward, rotate}
                                      {counterclockwise}
          theta:= (theta-pi);         {rotation required to get to horizontal}
                                      {from below}  
    degrees:= -1*(theta*(180/pi));    {rotation needed to put head to the left}
    SelectAll;

     {Rotates the comet to where the head is to the left}
       ScaleAndRotate(1,1,degrees);
       SetPicName('Rotate');
       SelectWindow('Image');
       Dispose;
       SelectWindow('Rotate');
       SelectTool('wand');    {Select correct tool}
  
         {Adjust the default threshold for *your* system !!}
         if threshold= 0 then 
           threshold:= 20;    {20 - default}
           SetThreshold(threshold);
          {Add new instructions}
           MoveTo(2,10);
begin
          PutMessage('Please highlight the comet to be measured and press M.  But first, press OK to close this box.');
          exit;
        end;


end;

{**************************************************************************}
macro 'Select the Comet to be measured [M]';
begin
    SetScale(0,'pixel');
    SetOptions('Area,Mean,Min/Max,Int.Den');
    GetThresholds(threshold,uthreshold);
    
{Measure the whole area and DNA content}
{Move the selected comet to a separate window}
    Copy;
    Clear;
    MakeNewWindow('Measure');
    Paste;                 
    
    GetRoi(left,top,width,height);
    CometLeft:= left;
    CometRight:= CometLeft+width;
    CometTop:= top;
    CometHeight:= height;
    CometLength:= width;
    
    Measure;
    TotalArea:= rArea[rCount]; {total number of pixels in this comet}
    AvgInt:= rMean[rCount]; {average pixel intensity in this comet}
    CometIntensity:= TotalArea*AvgInt; 
    Max:= rMax[rCount];           
    SetThreshold(0.70*Max);    {0.7  shows just nucleus or nucleus plus tail
                               pixels of similar intensity}
    ResetCounter;
    KillRoi;

{Select correct tool}
    SelectTool('wand');   
If q = 0 then
        begin
          PutMessage('Select the comet head and press N.  But first, press OK to close this box.');
          q:=1; {flag that this message has been shown once, won't show again}
              {until new image is rotated}
          exit;
        end;

end;
{**************************************************************************}
macro 'Measure the Nucleus [N]';

var
    TailLeft:  integer;
    Value:  integer; {value is always the intensity of a sampled pixel (0-255)}

begin
    SetScale(0,'pixel');
    SetOptions('Area,Mean,Min/Max,Int.Den');

    GetRoi(left,top,width,height);
    HeadLeft:= left;
    HeadTop:= top;
    HeadHeight:= height;
    Heady:= round(top+(height/2));    {head center}
    ImageLength:= width;     
    Headx:= round(HeadLeft+(ImageLength/2));    {head center position}
    KillRoi;
    SetThreshold(-1); 

{Determines the top of the comet's head}
    FOR i := 1 TO 100 DO
        begin
           if GetPixel(Headx, HeadTop-i) > 0 then {moves "up" from head center to} 
             HeadTop:= HeadTop-i                  {find first zero value pixel   }
           else 
             i:= 100;   {found headtop (getpixel was zero or less), stops cycle }
         end;

{Head diameter}
    DiameterY:= (Heady-HeadTop)*2;   
    DiameterX:= (Headx-CometLeft)*2;

{Tail Length, first ensuring that there are no negative tail lengths}
    TailLength:= CometLength-DiameterX;     
    if TailLength<0 then 
        TailLength:= 0;
{Makes sure that CometTop is at least as high as Headtop}
    If CometTop > Headtop then CometTop:=HeadTop;{y=coordinates increase downward}
    {It is best that the comet height is at least as big as the head diameter, so}
    If CometHeight < DiameterX then Cometheight := diameterX;
{Mark and measure the head}         
    ResetCounter;
    MakeOvalRoi(Headx-DiameterX/2, Heady-DiameterY/2, DiameterX, DiameterY);
    Measure;
    HeadArea:= rArea[rCount];
    HeadInt:= rMean[rCount];
    HeadDNA:= HeadArea*HeadInt;
    {Determine Center of Gravity of Head}
    HeadArm := 0;
    HeadWt:= 0;
    Headpixels:=0;       
{Determine the moment and total intensity of head}
For i := 0 TO DiameterX DO
    begin
       for k:= 0 to DiameterY  DO
           begin
              {Any the pixels outside the nuclear ellipse are rejected from head
               counting.  Zero value pixels are included since they are inside the 
               nuclear ellipse and contribute to head area, but not head DNA or
               head moment.  The number of pixels counted in this method
               differs slightly from the number determined using rArea above.
               This is likely due to subtle differences (such as rounding errors)
               in the way the two methods count pixels on the edge of the ROI}

               If (sqr((diameterX/2)-i)/sqr(diameterX/2))+((sqr((DiameterY/2)-
                 k))/sqr(diameterY/2))<=1 THEN {pixels are inside or on ellipse}
                     Begin
                       Value:= GetPixel(headleft+ i, headtop + k);
                               HeadArm:= HeadArm + (Value * i);
                               HeadWt:= HeadWt + Value;
                               Headpixels:=Headpixels+1;  {Increments head pixel}
                                                          {counter}
                     end;
           end;
   end;
    CGHeadX:= HeadArm/HeadWt; {position of head CG to the right of the left edge}
    LCGHeadX:= DiameterX-CGHeadX; {distance from head CG to right side of head}
KillRoi;

{Compute tail parameters}
    	TailArea:= TotalArea-HeadArea;
       If TailArea < 0 then TailArea := 0;  {Prevents negative tail areas}
      TailDNA:= CometIntensity-HeadDNA;
       If TailDNA < 0 then TailDNA := 0;     {Prevents negative TailDNA's}
    TailDNAPr:= (TailDNA/(CometIntensity))*100; 
    ATailMoment:= TailDNAPr*TailLength;  {Tail Moment as interpreted by Ashby 1995}
   
 
{Computes Corrie's tail moment and gets some numbers for Olive's tail moment}
    TailLeft:= Headx+(DiameterX/2)+1;{x position one pixel to right of head edge}        
    j:= 0; {initialize pixel counter}
    TailMoment:= 0; {initialize running moment sum}
    TailWt:= 0;  {initializes running tail weight sum}
    TDM := 0;    {initializes Hellmans Tail Distance Moment}
    Inertia:=0;  {initializes inertia}
    FOR i:= 0 TO (CometLength-(DiameterX/2)) DO {steps horizontally along x axis}
                                                {from head center to tip of tail}
      begin
          FOR n:= 0 TO CometHeight DO      {rasters vertically across tail}
             begin
               {Next the pixels within the nuclear ellipse are rejected from tail} 
               {counting}
                 If (sqr(i)/sqr(diameterX/2))+((sqr((CometHeight/2)-n))/
                                           sqr(diameterY/2))>1 THEN
               {Assumes for CTM that tail migration starts at right head edge}
                     Begin
                           TailstartY := (CometTop + n);
                              If TailstartY < Headtop then TailstartY:= Headtop;
                              If TailstartY > (HeadTop+DiameterY) then
                                 TailstartY:= (HeadTop+DiameterY);     

TailStartX:=0;
If (HeadY-TailStartY)<=(diameterY/2) then  {prevents sqrt failure}
TailstartX := round(sqrt(sqr(diameterX/2)*(1-(sqr(HeadY-TailStartY)/sqr(diameterY/2)))));                      
    {This code calculates the X offset to the right side of the nucleus    }
    {which is in parallel to the pixel being measured.  The horizontal     }
    {distance between this location on the nuclear ellipse and the pixel   }
    {under study will be used for calculation of the pixels moment for CTM.}       
    {Recall here that all of this only gets calculated for pixels outside  }
    {of the nuclear ellipse.                                               }
                         Value:= GetPixel(HeadX + i, CometTop + n);    
                            if Value > 0 then {only counts comet, not background}
                                 begin
                                   {If TailstartX larger than i, it means that}
                                   { the head ellipse contains most of the pixel}
                                   { of interest.  Don't use this pixel for     }   
                                   {Corrie's tail moment.   }
                                   If i > TailstartX then
                                     Begin
                                        TailMoment:= TailMoment+((i-TailstartX)*value);  
                                        {running total of pixel intensities}
                                        TailWt:= TailWt + Value;
                                        {Since we won't use pixels teetering on }
                                        {the rim of the ellipse for the moment, }
                                        {we won't use them for the TailWt either}                   
                                     end;
        
                                 {Calculate Inertia, as described by Hellman 1995}
                                 Inertia:= Inertia+(value*(sqr(i)*100) / CometIntensity);
                                 {TDM is tail distance moment for Hellman's tail    }
                                 {distance calculation, calculated from head center }
                                 {(rather than from right side of head) to the      } 
                                 {center of mass of tail                                        }
                                 TDM:= TDM + (i * value); {Running total TDM         }
                                 j:= j + 1; {increments pixel counter}
                               end;
                      end;

            end;
      end;
    TailPixels:= j; {Might be a bit different from TailArea}
    CGTailX:=0;
   If TailWt>0 then {prevents divide by zero errors}
        begin
         {The use for the TailStart offset accounts for DNA migrating from the }
         {head above and below the head-tail axis.                             }
          CGTailX:= TailMoment/TailWt;   {measured from left edge of tail}
          CTM:= (TailMoment / CometIntensity)*100;
          CGDiff:= (DiameterX-CGHeadX) + CGTailX; {distance between CG's}
          OTM:= TailDNAPr * CGDiff; {As described by Olive 1990}
         {Hellman seems to use geometric center of head to calculate Tail Distance (TD)}
         TD:= (TDM/TailWt); {Distance from center of head to tail CG, which includes the part of the}
                                        {tail which wraps around the head, using our ellipse exclusion routine  }
         TAI:=0;  {Presets value at zero, then leaves at zero if TailArea zero}
          If TailArea > 0 then  {don't divide by zero}
                TAI:= TailWt/TailArea; {Tail Average Intensity}
       end
    else
      begin
        TAI:= 0;
        TD:= 0;
      end;

    TDNA:= (TailArea*TAI*100) / (CometIntensity); {Hellman 1995}
    TMOM:= TDNA*TD; {also Hellman 1995}
{Redraws the comet and marks the boundary of the head}
    SetThreshold(-1);
    MakeOvalRoi(Headx-DiameterX/2, Heady-DiameterY/2, DiameterX, DiameterY);
    DrawBoundary;

{Display the results}
    SetForegroundColour(255);
    ERASE; 
    Writeln('');
    Writeln('');   
    Writeln('Sample ID:');
    Writeln('Slide Name   No');
    Writeln(' ',slide,'   'counter:3);
    Writeln('');
    Writeln('RESULTS:');
    Writeln('            Tail  % Tail     Ashbys  Olives    Corries');
    Writeln('Background Length  DNA       T-Mom    T-Mom     T-Mom');
    Writeln(SubAvgMin:7:2,TailLength:8:0,TailDNAPr:8:1,ATailMoment:11:2, OTM:9:2,
    CTM:10:2);
    Writeln('');
    Writeln('Type "K" to keep the measurement');
    Writeln('Type "D" to discard this measurement and make a new one');
    Writeln('');
    Writeln('');
				
    {These commands useful for troubleshooting have been}
    {commented out, but can be activated by removing brackets}
{
    Writeln('AvgMin   AllLinesSum   ImageHeight  ImageWidth');  
    Writeln(AvgMin:10, AllLinesSum:10,ImageHeight:10,ImageWidth:10);
    Writeln('Total Area   Tail Area  Avg Int');
    Writeln(TotalArea:11, TailArea:11, AvgInt:16);
    Writeln('Head Area    AvgHead Int');
    Writeln(HeadArea:11, HeadInt:16);
    Writeln('Head x    Head y');
    Writeln(Headx:11, Heady:16); 
    Writeln('DiameterX ', DiameterX:11);
    Writeln('DiameterY ', DiameterY:11); 
    Writeln('TailLeft ', TailLeft:10);
    Writeln('HeadArm    Head Weight   Headpixels');
    Writeln(HeadArm:11, HeadWt: 11, Headpixels:11);
    Writeln('CGHeadX  DiameterX  CGTailX CGDiff');
    Writeln(CGHeadX:11:4, DiameterX:11:4, CGTailX:11:4, CGDiff:10:4);
    Writeln('Tail Area ', TailArea:11);    
    Writeln('TailPixels ', Tailpixels:7); 
    Writeln('Total DNA    Head DNA   Tail DNA');
    Writeln(CometIntensity:11, HeadDNA:16, TailDNA:16);
    Writeln('TailMoment    TailWt ');
    Writeln(TailMoment:6, TailWt:11);
    Writeln('Inertia   TDM  TD');
    Writeln(Inertia:7:2,TDM:19, TD:7);
    Writeln('CometTop ', CometTop:11);
    Writeln('CometHeight ', CometHeight:11);
    Writeln('CometRight ', CometRight:11);
    Writeln('CometLeft ', CometLeft:11);
    Writeln('ImageLength ', ImageLength:11);       
    Writeln('Corrie Tail Moment', CTM:11:2); 
 }
{Select correct tool}
    SelectTool('wand'); 
  end;
{**************************************************************************}

macro 'Keep the Data [K]';

begin  
   Dispose; {Closes the summary window}
   SelectWindow(Name);    
   {Writes the data to the previously identified text file}
   Writeln(Slide:10, T, counter:3, T, TotalArea:11:0, T, AvgInt:10:2, T, HeadArea:8:0, T, HeadInt:9:2, T, TailLength:8:2, T, ATailMoment:10:2, T,OTM:9:2, T,  CTM:8:2, T, TailDNAPr:7:1, T, TAI:12:2, T, Inertia:14:2, T, TDNA:10:2, T, TD:10:2, T, TMOM:10:2, T, SubAvgMin:10:2, T, TDM:10:2, T, TailWt:10:2);

   counter:= counter+1;    {Increase the measurement counter}
   Save;

   SelectWindow('Rotate');    
   DrawBoundary; {Outlines the comet just recorded so it won't be examined twice}
end;

{**************************************************************************}


macro 'Discard this measurement and make a new one [D]';

begin   
    Dispose;
    SelectWindow('Rotate');    {Switch back to the Rotate window}
    DrawBoundary; {Outlines the comet just recorded so it won't be examined twice}
end;

{**************************************************************************}


macro 'Create a new text file [C]'; 

begin
    SelectWindow(Name);
    Dispose;
    FNAME;
end;


{**************************************************************************}
macro 'Enter a new slide name [S]'; 

begin
    SNAME;
end;


{**************************************************************************}


macro 'Append to an existing data file [A]'; 

begin
    Name:= WindowTitle;
end;



{**************************************************************************}


macro 'Quit [Q]';
begin
    DisposeAll;
    SelectWindow(Name);
    Close;  
    counter:= 0;
    Exit;
end;

{**************************************************************************}
{This macro was written by Anita Holland and Corrie Allen, Environmental Lung Center, National Jewish Medical and Research Center, Denver, Colorado. It maintains much of its feel to the excellent Comet 1.4 macro written by Christoph Helma and Maria Uhl. Some aspects of Geller's Comet moment macro were also incorporated along with our interpretation of Kent's tail moment (Corrie's Tail Moment).  Ms. Holland and Dr. Allen were supported by a grant from the U.S. Environmental Protection Agency during development of this macro.  Questions, comments, and bug reports can be directed to Corrie Allen at allenc@njc.org.

References
Ashby, J., H. Tinwell, P.A. Lefevre, M.A. Browne.  The single cell gell electrophoresis assay for induced DNA damage (comet assay): measurement of tail length and moment.  Mutagenesis 10:
85-90, 1995.

Kent,C.R.H., J.J. Eady, G.M. Ross, and G.G. Steel.  The comet moment as a measure of DNA damage in the comet assay.  Int.J.Radiat.Biol. 67: 655-660, 1995.

Olive, P.L., J.P. Banath, R. Durand.  Heterogeneity in radiation-induced DNA damage and repair in tumor and normal cells measured using the "comet" assay."  Radiat.Res. 122: 86-94,
1990.

Helma, C. and M. Uhl, A public domain image analysis program for the single 
cell gel electrophoresis (comet) assay, submitted to Mutation research 1999.

Comet moment macro, V1.0 9/5/97, Herbert M. Geller

Hellman, B., H. Vaghef, and B. Bostršm (1995) The concepts of tail moment and 
tail inerta in the single cell gel electrophoresis assay, Mutation Research, 
336, 123-131.


There are ten operations in this macro:

Acquire an image form a file [F]
Allows a file to be loaded into NIH Image. The initial picture will be 
adjusted to gray scale. The macro will prompt for user interactions.

Rotate the comet [R]
Allows the comets to be rotated so that their tails are to the right of the 
comets' heads. Draw a line from the center of the comet's head through the 
center of the tail.

Select the comet to be measured [M]
Selects the comet to be analyzed by the program.

Measure the nucleus [N]
Allows for the comet's head to be selected. 

Keep the data [K]
Allows the data to be saved to a text file, which later may be 
opened in Microsoft Excel and perhaps other spreadsheet programs.

Discard this measurement and make a new one [D]
Discards the current data without saving to the text file.

Create a new text file [C]
Creates a new text file to save the data.

Enter a new slide [S]
Creates a new slide name.

Append to an existing data file [A]
Allows for an existing data file to have additional data added.
Open the data file and move the cursor to a new line at 
the bottom of the page. While the file is still active perform
this function. The macro will now save its data to this file.

Quit [Q]
Shuts down the macro. 


The current threshold setting is 20. This may be adjusted in the 
section 'Rotate the Comet [R]'. Decreasing the threshold causes 
less intense areas to be seen. This may be helpful if the area 
between the comet's head and tail is not read and the program 
believes there are two separate comets instead of one.
If the comet head and tail are separate, press the Shift key
and highlight both.

The data file can be examined in Excel without closing NIH Image.  However,
Excel must be closed before adding more data.  NIH Image protests when asked
to write to a file currently in by Excel.  In Excel 2001, open the file using the pull-down menu, select the "Delimited" file type on page 1 of the Text Import Wizard, press Next, select Tab as the delimiter, press Next, then ensure that General is chosen for Column Data Format on page 3.  Press finish and the spreadsheet should be presented.  Each column should have its own set of headings.

Revision History
ELC_Comet1.1  10/7/02  Zero'd TDM before each measurement cycle in Macro N.  Previously, sum would accumulate from cycle to cycle. Also corrected some spelling.
}