Connect the pixels
JavaScript (ES6), 155 121 103 102 characters
let f =
s=>s.replace(/#/g,(c,p)=>'#│─┘─└─┴││┐┤┌├┬┼'[t=x=>s[p+x]==c,8*t(w=s.search`
`+1)+4*t(1)+2*t(-1)+t(-w)])
console.log(f(
'# #### ## #\n' +
'## # ## #\n' +
' #### ##'
));Edit: saved 18 bytes with the help of ETHproductions
Edit: saved 1 byte by using the 1st parameter of replace() as '#'
How it works
We iterate on all # characters found in the input string. For each of them, we test whether its neighbors are also # characters using the t() function:
t = x => s[p + x] == c // where c = '#'
The parameter x of the t() function is the offset of the neighbor with respect to the current position p. We use -1/+1 to test left/right neighbors and -w/+w for top/bottom neighbors (where w is the width of a row, i.e. the position of the first line-break + 1).
Each neighbor is assigned a different weight (1, 2, 4 or 8) according to the following compass:
1
2 + 4
8
Each weight combination leads to unique value in [ 0 .. 15 ]. For instance, if both the neighbor at the top and the neighbor on the right are set, the sum will be 1 + 4 = 5, which is translated into └ using this table:
00 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15
# │ ─ ┘ ─ └ ─ ┴ │ │ ┐ ┤ ┌ ├ ┬ ┼
Therefore, '#│─┘─└─┴││┐┤┌├┬┼'[weight_sum] leads to the expected character.
J, 82 72 66 bytes
(ucp' #───│┌┐┬│└┘┴│├┤┼'){~]+]*3 3((2#.1 7 3 5{,);._3)0,.~0,.0,~0,]
The input is a boolean table of 1's and 0's. The rules state that the box characters each count as one byte, not three, and that has been applied here.
Usage
f =: (ucp' #───│┌┐┬│└┘┴│├┤┼'){~]+]*3 3((2#.1 7 3 5{,);._3)0,.~0,.0,~0,]
m =: 1 0 1 1 1 1 0 1 1 0 1 , 1 1 0 1 0 0 1 1 0 0 1 ,: 0 0 0 1 1 1 1 0 0 1 1
m { ' #'
# #### ## #
## # ## #
#### ##
f m
│ ─┬── ┌─ │
└─ │ ┌┘ │
└──┘ ─┘
' #' {~ m =: 5 5 $ 1
f m
┌┬┬┬┐
├┼┼┼┤
├┼┼┼┤
├┼┼┼┤
└┴┴┴┘
' #' {~ m =: 5 9 $ 1 0
# # # # #
# # # #
# # # # #
# # # #
# # # # #
f m
# # # # #
# # # #
# # # # #
# # # #
# # # # #
Explanation
First the input is padded with 0's on all sides.
] m =: 1 0 1 1 1 1 0 1 1 0 1 , 1 1 0 1 0 0 1 1 0 0 1 ,: 0 0 0 1 1 1 1 0 0 1 1
1 0 1 1 1 1 0 1 1 0 1
1 1 0 1 0 0 1 1 0 0 1
0 0 0 1 1 1 1 0 0 1 1
(0,.~0,.0,~0,]) m
0 0 0 0 0 0 0 0 0 0 0 0 0
0 1 0 1 1 1 1 0 1 1 0 1 0
0 1 1 0 1 0 0 1 1 0 0 1 0
0 0 0 0 1 1 1 1 0 0 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0
Then each subarray of size 3 is selected
3 3 <;._3 (0,.~0,.0,~0,]) m
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│
│0 1 0│1 0 1│0 1 1│1 1 1│1 1 1│1 1 0│1 0 1│0 1 1│1 1 0│1 0 1│0 1 0│
│0 1 1│1 1 0│1 0 1│0 1 0│1 0 0│0 0 1│0 1 1│1 1 0│1 0 0│0 0 1│0 1 0│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│0 1 0│1 0 1│0 1 1│1 1 1│1 1 1│1 1 0│1 0 1│0 1 1│1 1 0│1 0 1│0 1 0│
│0 1 1│1 1 0│1 0 1│0 1 0│1 0 0│0 0 1│0 1 1│1 1 0│1 0 0│0 0 1│0 1 0│
│0 0 0│0 0 0│0 0 1│0 1 1│1 1 1│1 1 1│1 1 0│1 0 0│0 0 1│0 1 1│1 1 0│
├─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│0 1 1│1 1 0│1 0 1│0 1 0│1 0 0│0 0 1│0 1 1│1 1 0│1 0 0│0 0 1│0 1 0│
│0 0 0│0 0 0│0 0 1│0 1 1│1 1 1│1 1 1│1 1 0│1 0 0│0 0 1│0 1 1│1 1 0│
│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
Then only 5 of the values in each subarray is considered
┌───┐
│xAx│
│CED│
│xBx│
└───┘
The values ABCD are selected by flattening each subarray and selecting at indices 1 7 3 5. Those values are multiplied by E which is at index 4. It is then converted from a list of binary digits to a decimal, and incremented by E. The x values are not needed.
3 3 (4&{([+2#.*)1 7 3 5&{)@,;._3 (0,.~0,.0,~0,]) m
5 0 2 8 4 3 0 6 3 0 5
10 3 0 13 0 0 6 11 0 0 13
0 0 0 10 4 4 11 0 0 2 11
This is used as an index to select which character to draw according to the table below (reordered a bit for golfing). The last column matches the output value of each subarray to a box character.
0 (space) 0
1 # 1
2 ┌ 6
3 ┬ 8
4 ┐ 7
5 ├ 14
6 ┼ 16
7 ┤ 15
8 └ 10
9 ┴ 12
10 ┘ 11
11 │ 5, 9, 13
12 ─ 2, 3, 4
Also, in J, the string ' #───│┌┐┬│└┘┴│├┤┼' uses 8-bit characters making it have a length of 47 (for each byte) for the 17 characters needed. The command ucp converts it to 16-bit characters which allows it to be length 17.
Python 2.7, 318 315 bytes (270 267 chars)
I'm sure this can be golfed further (particularly I'd love to get rid of that annoying first-line comment) but here's my entry:
#encoding:utf-8
f=lambda t:(lambda l,s:'\n'.join(''.join((u'┼├┤│┬┌┐│┴└┘│───#'[(s==l[i][j-1])+2*(s==l[i][j+1])+4*(i<1 or s==l[i-1][j])+8*(i>len(l)-2 or s==l[i+1][j])],s)[s==l[i][j]]for j in range(len(l[i])-1))for i in range(len(l))))([l+' 'for l in t.split('\n')],' ')
Here's an explanation of how the whole thing works:
#encoding:utf-8 # Dammit, Python. This adds an extra 16 bytes!
f=lambda t:( # main lambda function
lambda l,s: # inner lambda so we can pass it "local constants" (see last line)
'\n'.join( # join each line
''.join( # join each char within the line
(u'┼├┤│┬┌┐│┴└┘│───#'[ # string of all possible characters, indexed by binary 0-15 based on adjacent chars
(s==l[i][j-1])+ # left
2*(s==l[i][j+1])+ # right
4*(i<1 or s==l[i-1][j])+ # up ('i<1' just yields zero in case this is the first line, so that we don't get index problems)
8*(i>len(l)-2 or s==l[i+1][j])], # down ('i>len(l)-2' is same as above)
s)[s==l[i][j]] # if original is space, choose space, else choose the previously chosen box-drawing char
for j in range(len(l[i])-1)) # do this process for each char (excluding last, which is a space)
for i in range(len(l))) # do this for each line
)([l+' ' for l in t.split('\n')],' ') # call the inner lambda with two parameters: first, the text split into lines; second, a space char (actually makes code shorter)
EDIT: Removed some spaces before for ... in ...